smaple.tr
Backend ve API

WebSocket Nedir? Nasıl Çalışır, Ne Zaman SSE Yeterli?

Mehmet Kurtipek
20 Aralık 2025
14 dk okuma
Backend ve API
WebSocket
SSE
Gerçek zamanlı iletişim
Node.js

WebSocket, istemci (çoğunlukla tarayıcı) ile sunucu arasında tek bir TCP bağlantısı üzerinden açık kalan, iki yönlü bir iletişim kanalı kuran protokoldür; 2011'de RFC 6455 ile standart hale geldi. Bağlantı sıradan bir HTTP isteğiyle başlar. Sunucu "101 Switching Protocols" cevabını verdikten sonra iki taraf da yeni bir istek açmadan, istediği an mesaj gönderebilir. Sohbet, çok oyunculu oyunlar ve ortak doküman düzenleme gibi verinin iki yönde sürekli aktığı işlerde kullanılır. Veri yalnızca sunucudan istemciye akıyorsa (bildirimler, canlı fiyat ekranı, adım adım gelen bir LLM cevabı) çoğu zaman Server-Sent Events (SSE) daha basit bir seçimdir.

Protokolün kendisi işin kolay kısmı. Projelerde asıl zaman alan şunlar: tarayıcıdan gelen bağlantıyı nasıl doğrulayacağınız, reverse proxy'nin hiç bitmeyen bir bağlantıya ne yaptığı ve on saniyeliğine kopan bir istemcinin geri döndüğünde ne gördüğü. Yazının ikinci yarısı bunlarla ilgili; örnekler Node.js ile.

HTTP'den farkı ne?

HTTP'de konuşmayı her zaman istemci başlatır: istek gönderir, cevabı alır, iş biter. Sunucunun "yeni bir mesaj var" diye kendiliğinden söze girmesinin yolu yoktur. Bu yüzden uzun süre iki ara çözüm kullanıldı. Polling'de istemci birkaç saniyede bir "yeni bir şey var mı?" diye sorar; cevapların çoğu boş döner ve bir güncelleme en kötü ihtimalle iki sorgu arasındaki süre kadar gecikir. Long polling'de sunucu isteği yeni veri gelene kadar bekletir, cevabı verince istemci hemen yeni bir istek açar. Gecikme azalır ama her mesaj için yine yeni bir HTTP isteği ve başlıkları gider.

WebSocket'te bağlantı bir kez kurulur ve açık kalır. Bundan sonra sunucu da istemci de karşı tarafın sormasını beklemeden mesaj gönderir. Her mesajla giden ek yük de koca bir HTTP başlığı yerine birkaç baytlık bir çerçeve başlığından ibaret.

WebSocket nasıl çalışır?

El sıkışma (handshake)

Bağlantı, protokol değiştirmek isteyen bir HTTP/1.1 GET isteğiyle başlar. RFC 6455'teki örnekten uyarlanmış bir el sıkışma şöyle görünür:

GET /ws HTTP/1.1
Host: app.example.com
Upgrade: websocket
Connection: Upgrade
Origin: https://app.example.com
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

Sec-WebSocket-Key, istemcinin rastgele ürettiği bir değerdir. Sunucu bu değerin sonuna standartta sabit olarak tanımlanmış bir GUID ekler, sonucu SHA-1 ile özetleyip Base64'e çevirir ve Sec-WebSocket-Accept olarak geri gönderir. Böylece sunucunun bu el sıkışmayı gerçekten okuduğu anlaşılır. Bağlananın kim olduğunu doğrulamak ayrı bir iş; aşağıda ona da geleceğiz.

Bağlantı açıldıktan sonra

101 cevabından sonra aynı TCP bağlantısı üzerinden artık WebSocket çerçeveleri (frame) akar. Bir çerçevenin başlığı 2 ile 14 bayt arasındadır ve çerçeve metin (UTF-8) ya da ikili (binary) veri taşıyabilir. İstemcinin gönderdiği her çerçeve 4 baytlık bir anahtarla maskelenir. Taraflardan biri ping gönderdiğinde diğeri pong ile cevap vermek zorundadır; bağlantının hâlâ açık olduğunu anlamanın standart yolu budur.

Şifresiz bağlantı ws:// ile varsayılan olarak 80 numaralı porttan, TLS ile şifrelenmiş bağlantı wss:// ile 443'ten kurulur. Yani WebSocket, sitenizin zaten kullandığı portu paylaşabilir; ayrı bir port açmanız gerekmez.

WebSocket'i HTTP/2 (RFC 8441) ve HTTP/3 (RFC 9220) üzerinde çalıştırmak da standartlaştı. Ancak tarayıcının, sunucunun ve aradaki her proxy'nin bunu desteklemesi gerekiyor. Planlarken her WebSocket'i ayrı bir TCP bağlantısı olarak düşünmek daha doğru olur.

Node.js ile basit bir örnek

Node.js'te ws kütüphanesiyle yazılmış aşağıdaki sunucu, gelen her mesajı bağlı olan herkese iletir:

// npm install ws
import WebSocket, { WebSocketServer } from 'ws';

const wss = new WebSocketServer({ port: 8080, maxPayload: 64 * 1024 });

wss.on('connection', (ws) => {
  ws.on('error', console.error);
  ws.on('message', (data, isBinary) => {
    // Gelen mesajı bağlı olan herkese ilet
    for (const client of wss.clients) {
      if (client.readyState === WebSocket.OPEN) client.send(data, { binary: isBinary });
    }
  });
  ws.send('Bağlandın');
});

Tarayıcı tarafında ek bir kütüphaneye gerek yok:

const ws = new WebSocket('ws://localhost:8080'); // canlıda: wss://alanadiniz.com/ws
ws.addEventListener('open', () => ws.send('merhaba'));
ws.addEventListener('message', (e) => console.log('sunucudan:', e.data));
ws.addEventListener('close', (e) => console.log('bağlantı kapandı, kod:', e.code));

İki sekmede açıp birinden mesaj gönderdiğinizde diğerinde de görürsünüz. Bu örnek çalışır ama canlıya çıkmaya hazır değildir: kimlik doğrulama, kopan bağlantıların temizlenmesi ve yeniden bağlanma eksik. Hepsine aşağıda değiniyoruz.

Socket.IO hakkında bir not: Socket.IO, altta WebSocket'i (gerekirse HTTP long polling'i) kullanan, kendine ait bir protokoldür. Odalar (room), mesaj onayı (acknowledgement) ve otomatik yeniden bağlanma gibi işleri hazır verir. Buna karşılık düz bir WebSocket istemcisi Socket.IO sunucusuna bağlanamaz. İki ucu da siz yazıyorsanız bu bir sorun değil; dışarıya açık bir API sunacaksanız düz WebSocket tercih edin.

WebSocket mi, SSE mi?

SSE, sunucudan tarayıcıya tek yönlü akış için düz HTTP üzerinde çalışan bir standarttır. Tarayıcı bir GET isteği gönderir, sunucu da cevabı hiç kapatmaz. Content-Type: text/event-stream başlığıyla cevap verir ve olayları düz metin olarak yazar: bir ya da birkaç data: satırı, isteğe bağlı olarak event: (olay adı), id: ve retry: (milisaniye cinsinden yeniden bağlanma süresi). Her olayı boş bir satır bitirir:

id: 1042
event: siparis
data: {"siparis": 1042, "durum": "yolda"}

Tarayıcıdaki EventSource API'si bağlantı koptuğunda birkaç saniye bekler, kendiliğinden yeniden bağlanır ve aldığı son olayın kimliğini Last-Event-ID başlığıyla gönderir. Kaçırılan olayları yeniden göndermek ise sunucunun işidir; bunun için son olayları bir yerde saklamanız gerekir. Biçimin ayrıntıları MDN'in SSE sayfasında var.

Bu otomatik yeniden bağlanma yalnızca ağ hatalarında işe yarar. Yeniden bağlanma isteğine 200 dışında bir cevap gelirse (deploy sırasında proxy'den 502, oturum bitmişse 401), HTML standardına göre tarayıcı bağlantıyı tamamen bırakır: readyState CLOSED olur ve bir daha denemez. Böyle bir deploy'dan sonra ekranda açık kalan izleme paneli de eski rakamları göstermeye devam eder. Bu yüzden error olayında durumu kontrol edin; CLOSED ise birkaç saniyelik rastgele bir beklemeden sonra yeni bir EventSource açın. Yeni nesne Last-Event-ID göndermez. Kaçırılan olaylar gerekiyorsa son kimliği URL'de (/events?since=1042) iletin ve sunucuda ikisini de okuyun. error olayı hangi durum kodunun döndüğünü de söylemez; oturum sona erebiliyorsa yeniden açmadan önce oturumu normal bir istekle kontrol edin.

SSE'nin iki sınırı insanları sık sık şaşırtır. Birincisi, EventSource yalnızca GET isteği yapar ve kabul ettiği tek seçenek withCredentials'tır. Ne Authorization başlığı ekleyebilirsiniz ne de istek gövdesi (body) gönderebilirsiniz. İkincisi, HTTP/1.1'de tarayıcı bir alan adına en fazla altı bağlantı açar ve bu sayı bütün sekmeler için ortaktır. Uygulamanızı altı sekmede açmış bir kullanıcı hakkını doldurmuştur; alan adınıza giden bir sonraki istek sırada bekler. HTTP/2'de akışlar tek bir bağlantıyı paylaşır ve sınırı sunucu belirler, genellikle 100 ya da daha fazla; yani SSE'yi HTTP/2 üzerinden sunmak çoğu uygulamada sorunu ortadan kaldırır.

SSE

WebSocket

Yön

Sunucudan istemciye

İki yönlü, her an

Altında ne var

Açık kalan tek bir HTTP cevabı

HTTP/1.1 el sıkışmasından sonra kendi çerçeve yapısı

Veri

UTF-8 metin

Metin ya da ikili veri

Tarayıcı API'si

EventSource

WebSocket

Kopunca yeniden bağlanma

Otomatik

Sizin yazmanız gerekir

Kaçırılan mesajlar

Last-Event-ID ile, sunucu olayları sakladıysa

Size kalmış

Tarayıcıdan özel başlık

Gönderilemez, yalnızca çerez

Gönderilemez, yalnızca çerez

Tarayıcı başına bağlantı

HTTP/1.1'de alan adı başına 6 (bütün sekmeler toplamı), HTTP/2'de çok daha fazla

Her soket ayrı bir TCP bağlantısı

Proxy ve CDN

Genelde geçer, tamponlamaya dikkat

Aradaki her katmanın Upgrade isteğini geçirmesi gerekir

Tipik kullanım

Bildirim, haber akışı, izleme paneli, ilerleme çubuğu, LLM cevabı

Sohbet, oyun, ortak düzenleme, kullanıcının izlediği kadar işlem de yaptığı araçlar

Pratik bir kural: kullanıcı çoğunlukla izliyor, arada bir işlem yapıyorsa (form gönderiyor, bir talebi onaylıyor) SSE ile normal POST istekleri yeter, API'nizin geri kalanı da alıştığınız REST düzeninde kalır. İstemci saniyede birkaç mesaj gönderiyorsa (ortak bir editörde imleç konumu gibi), ikili veri gerekiyorsa ya da iki yönde de sırası korunan tek bir kanal kodunuzu sadeleştiriyorsa WebSocket'i seçin.

SSE yalnızca metin taşır; ikili veriyi Base64'e çevirmek boyutu yaklaşık üçte bir büyütür. Veri dakikada bir değişiyorsa ikisine de gerek yok: 30 saniyede bir atılan bir GET isteği önbelleğe alınabilir, her proxy'den geçer ve sunucuda açık bağlantı tutmaz.

Arada ne olduğuna da bakın. Bazı ağlar WebSocket'e geçen (upgrade edilen) bağlantıları engeller ya da bozar; düz bir HTTP akışı daha sık geçer, gerçi bir proxy onu tamponlayabilir. Kullanıcılarınız sıkı kurallı kurumsal ağlardan bağlanıyorsa karar vermeden önce oradan deneyin.

Kendi backend servisleriniz arasındaki iletişimde ise ikisi de ilk akla gelmesi gereken araç değil; orada bir mesaj kuyruğu ya da gRPC akışları genelde daha uygun düşer.

SSE'nin şu sıralar en görünür kullanıcıları LLM API'leri. Örneğin Anthropic'in Messages API'si, POST isteğinde "stream": true gönderdiğinizde cevabı server-sent events olarak akıtıyor. Böyle bir akışı kendi ön yüzünüze aktarırken büyük ihtimalle fetch() ile okuyup olayları kendiniz ayrıştırırsınız, çünkü EventSource POST gövdesi gönderemez. Model Context Protocol da aynı yolu seçti: Streamable HTTP taşımasında her mesaj bir POST isteğidir, cevap JSON ya da SSE akışı olarak döner.

Canlıya alırken dikkat edilecekler

Kimlik doğrulama: tarayıcı başlık gönderemez

Tarayıcıdaki WebSocket constructor'ı yalnızca bir URL ve isteğe bağlı bir alt protokol listesi alır. EventSource ise URL ve withCredentials dışında bir şey kabul etmez. Yani REST API'nizin beklediği Authorization: Bearer başlığını ikisiyle de gönderemezsiniz. İşe yarayan yollar şunlar:

  • Oturum çerezi. Tarayıcı, WebSocket el sıkışmasında ve EventSource isteklerinde çerezleri gönderir. WebSocket'te bunun bir bedeli var: tarayıcılar el sıkışmaya CORS uygulamaz, dolayısıyla başka bir sitedeki sayfa da sizin sunucunuza soket açabilir ve kullanıcının çerezi bu isteğe eklenir (cross-site WebSocket hijacking). OWASP'ın WebSocket güvenliği notları, her el sıkışmada Origin başlığını açık bir izin listesiyle karşılaştırmayı ve SameSite=Lax ya da Strict çerez kullanmayı öneriyor.
  • İlk mesajda token. Soketi wss:// üzerinden açın, token'ı ilk mesaj olarak gönderin; doğrulanana kadar sunucu korumalı hiçbir veri göndermesin.
  • Sorgu dizesinde (query string) token göndermekten kaçının, çünkü URL'ler erişim loglarına düşer. Başka yolunuz yoksa bağlanmadan hemen önce REST API'den kısa ömürlü, tek kullanımlık bir bilet (ticket) alın ve URL'de onu kullanın.

SSE'de de çerez aynı şekilde çalışır: aynı origin'den ya da withCredentials: true ve uygun CORS başlıklarıyla farklı bir origin'den. Bearer token şartsa akışı fetch() ile kendiniz okuyun.

Kontrolü el sıkışma tamamlanmadan yapın. ws kütüphanesinde bunun yolu HTTP sunucusunun upgrade olayını kendiniz ele almak; kütüphanenin dokümantasyonu eski verifyClient seçeneğini önermiyor. Kabaca şöyle:

import http from 'node:http';
import { WebSocketServer } from 'ws';

const IZINLI_ORIGINLER = new Set(['https://app.example.com']);
const server = http.createServer();
const wss = new WebSocketServer({ noServer: true, maxPayload: 64 * 1024 });

server.on('upgrade', async (req, socket, head) => {
  socket.on('error', console.error);
  // oturumKullanicisi() size ait: çerezdeki oturumu bulsun, geçersizse null dönsün.
  const user = IZINLI_ORIGINLER.has(req.headers.origin)
    ? await oturumKullanicisi(req.headers.cookie)
    : null;

  if (!user) {
    socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
    socket.destroy();
    return;
  }
  wss.handleUpgrade(req, socket, head, (ws) => wss.emit('connection', ws, req, user));
});

wss.on('connection', (ws, req, user) => {
  ws.isAlive = true;
  ws.on('pong', () => { ws.isAlive = true; });
  ws.on('error', console.error);
  ws.on('message', (data) => {
    let msg;
    try { msg = JSON.parse(data); } catch { return ws.close(1008, 'invalid JSON'); }
    mesajiIsle(user, msg, ws);
  });
});

// 30 saniyede bir: son ping'e cevap vermeyen soketi kapat, kalanlara ping at.
setInterval(() => {
  for (const ws of wss.clients) {
    if (!ws.isAlive) { ws.terminate(); continue; }
    ws.isAlive = false;
    ws.ping();
  }
}, 30_000);

server.listen(8080);

Tarayıcıyla ilgili bir tuzak daha var: el sıkışma başarısız olduğunda sayfa HTTP durum kodunu hiçbir zaman göremez. Siz 401 dönmüş olun ya da sunucu kapalı olsun, sayfaya yalnızca bir error olayı ve 1006 kodlu bir close olayı düşer. Oturum, istemci bağlı değilken sona erebiliyorsa ya yeniden bağlanmadan önce oturumu normal bir istekle kontrol edin ya da bağlantıyı kabul edip hemen kendi kodunuzla kapatın. RFC 6455, 4000 ile 4999 arasındaki kodları uygulamalara bırakır; örneğin 4001'i "yeniden giriş yap" anlamında kullanabilirsiniz.

Mesaj boyutu

ws varsayılan olarak 100 MiB'a kadar mesaj kabul eder. OWASP tipik uygulamalar için 64 KB ya da altını öneriyor; örneklerdeki maxPayload bu yüzden orada. Sınır aşılınca ws bağlantıyı 1009 koduyla kapatır.

Kopan bağlantıları fark etmek: ping/pong

Telefon asansörde çekmediğinde ya da Wi-Fi'den mobil veriye geçtiğinde bağlantı çoğu zaman kapanış çerçevesi gönderilmeden kopar. Sunucu bunu kendiliğinden fark etmez ve ölü soketler birikir. Yukarıdaki döngü 30 saniyede bir her sokete ping atar, bir önceki ping'e pong dönmeyen soketi terminate() ile kapatır. Aynı ping'ler, boşta kalan bağlantıları kesen proxy'lerin sağlıklı bağlantılara dokunmamasını da sağlar.

Reverse proxy ayarı

Upgrade ve Connection hop-by-hop başlıklardır; reverse proxy, siz açıkça belirtmedikçe bunları arkadaki sunucuya iletmez. nginx'in WebSocket dokümantasyonundaki örneğe göre:

location /ws/ {
    proxy_pass http://app;
    proxy_http_version 1.1;   # nginx 1.29.7'den itibaren zaten varsayılan
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
}

location /events {
    proxy_pass http://app;
    proxy_buffering off;      # ya da uygulamadan X-Accel-Buffering: no gönderin
}

nginx, arkadaki sunucu 60 saniye boyunca hiçbir şey göndermezse bağlantıyı kapatır (proxy_read_timeout). Bu süreyi uzatabilirsiniz ama daha iyisi hattan daha sık bir şey geçmesini sağlamak; 30 saniyelik ping bunu zaten yapıyor. SSE'de bunun karşılığı, iki nokta üst üste ile başlayan bir yorum satırını (örneğin : keep-alive) 15 saniyede bir göndermek. SSE için tamponlamayı da kapatın; açık kalırsa olaylar birikip toplu halde gelir. Uygulamanızdaki bir gzip ara katmanı da aynı etkiyi yapabilir.

Birden fazla sunucu

Sticky session konusu her ölçeklendirme sohbetinde açılır, çoğu zaman da yanlış anlaşılır. Düz bir WebSocket tek bir TCP bağlantısıdır. Yük dengeleyici onu bir kez bir sunucuya yönlendirdikten sonra bağlantı kapanana kadar orada kalır; bu yüzden sticky session gerekmez, SSE akışı için de gerekmez. İstisna Socket.IO: istemci varsayılan olarak HTTP long polling ile başlar ve bu ayrı isteklerin aynı sürece ulaşması gerekir. Bu yüzden Socket.IO dokümantasyonu, istemciyi yalnızca WebSocket taşımasıyla sınırlamadığınız sürece sticky session istiyor.

İkinci sunucuyu eklediğiniz anda, birinde üretilen olayın diğerine bağlı istemcilere de ulaşması gerekir. Bu genelde her sunucunun abone olduğu bir pub/sub kanalıyla çözülür. En sık Redis kullanılır; Socket.IO'nun da bunun için adaptörleri var. Yalnız Redis pub/sub her mesajı en fazla bir kez iletir: o anda bağlantısı kopuk olan abone mesajı bir daha alamaz. "Yazıyor..." göstergesi gibi şeyler için bu kabul edilebilir. İstemcilerin koptuktan sonra kaçırdıklarını alması gerekiyorsa olayları kalıcı bir yerde (bir Redis Stream ya da veritabanı tablosu) tutun ve onun kimliklerini SSE'deki id: değeri olarak kullanın. Böylece başka bir sunucuya düşen yeniden bağlantıya da cevap verebilirsiniz.

Deploy anı da ayrı dikkat ister. Bir sunucuyu yeniden başlatmak ona bağlı bütün istemcileri aynı anda düşürür; hepsi aynı aralıklarla yeniden denerse aynı saniyede geri gelirler. İstemcinin yeniden deneme süresine rastgele bir pay (jitter) ekleyin:

function baglan(deneme = 0) {
  const ws = new WebSocket('wss://app.example.com/ws');
  ws.onopen = () => { deneme = 0; };
  ws.onmessage = (e) => goster(JSON.parse(e.data));
  ws.onclose = (e) => {
    if (e.code === 4001) return girisEkraniniAc(); // kendi "oturum bitti" kodumuz
    // 0 ile min(30 sn, 1 sn × 2^deneme) arasında rastgele bekle ("full jitter")
    const bekleme = Math.random() * Math.min(30_000, 1_000 * 2 ** deneme);
    setTimeout(() => baglan(deneme + 1), bekleme);
  };
}
baglan();

EdgeHunters'ta WebSocket

Dublin merkezli EdgeHunters için geliştirip Temmuz 2023'ten 2026 başına kadar işlettiğimiz bahis oranı veri platformunda WebSocket iki uçta da vardı. Bazı bahis siteleri oranlarını WebSocket akışlarıyla yayınlıyor; bu yüzden veri toplayıcılarımızın bir kısmı bizzat WebSocket istemcisiydi. Bu, işin kolay tarafıydı, çünkü sunucuda çalışan bir istemci istediği başlığı gönderebilir ve yukarıdaki tarayıcı kısıtlarının hiçbiri onu ilgilendirmez. Sistemin içinde Redis hem Celery işçilerinin kuyruğu hem de ön yüz için önbellekti; canlı oranlar ürünün ön yüzüne WebSocket üzerinden ulaşıyordu.

Soket, o platformun küçük bir parçasıydı. Vaka çalışmasında anlattığımız işlerin çoğu onun arkasında duruyor: her bahis sitesi için ayrı bir toplayıcı, her sitenin takım ve lig adlarını aynı maça eşleyen tablolar, Slack'e uyarı gönderen anomali kontrolleri ve bir toplayıcı çöktüğünde devreye giren üçüncü taraf bir oran API'si. Benzer bir şey planlıyorsanız emeğin çoğunu oraya ayırın. WebSocket, arkasındaki hat ne üretirse onu taşır; bayat oranlar dahil.

Sık sorulan sorular

WebSocket ile HTTP aynı portu kullanabilir mi?

Evet. Bağlantı bir HTTP isteği olarak başladığı için ws:// 80, wss:// 443 numaralı porttan kurulur ve sitenizle aynı sunucu ve port üzerinden çalışabilir. Arada bir reverse proxy varsa Upgrade başlıklarını iletecek şekilde ayarlanması gerekir.

WebSocket için sticky session gerekir mi?

Düz WebSocket için gerekmez, çünkü bağlantı açıldığı sunucuda kalır. Socket.IO için, istemci yalnızca WebSocket taşımasını kullanmıyorsa gerekir; long polling istekleri aynı sürece ulaşmak zorundadır.

wss nedir, WebSocket güvenli mi?

wss://, TLS ile şifrelenmiş WebSocket bağlantısıdır, yani HTTPS'in WebSocket'teki karşılığı. OWASP canlı ortamda şifresiz ws:// kullanılmamasını söylüyor. Şifreleme tek başına yetmez: Origin kontrolü, kimlik doğrulama, mesaj boyutu sınırı ve OWASP Top 10 listesindeki olağan web güvenliği kuralları WebSocket için de geçerli.

WebSocket mi daha hızlı, SSE mi?

Açık bir bağlantı üzerinden sunucudan istemciye mesaj göndermede ikisinin de yapısal bir gecikme avantajı yok; ikisi de zaten kurulmuş bir TCP bağlantısına yazar. WebSocket'in mesaj başına ek yükü daha düşüktür ve ikili veri taşıyabilir; bu fark yüksek mesaj hızlarında hissedilmeye başlar. Uygulamanın ne kadar hızlı hissettirdiğini çoğu zaman protokolden çok proxy tamponlaması ve yeniden bağlanma davranışı belirler.

Socket.IO ile WebSocket aynı şey mi?

Hayır. Socket.IO, WebSocket'i taşıma katmanı olarak kullanan ayrı bir protokol ve kütüphane. İstemciyi de sunucuyu da siz yazıyorsanız ve odalar, mesaj onayı, yeniden bağlanma, long polling yedeği gibi özellikleri hazır istiyorsanız iyi bir seçim. Başkalarının istemcileri bağlanacaksa ya da bu özelliklerin yalnızca bir ikisine ihtiyacınız varsa düz WebSocket (Node.js'te ws) daha doğru.

Bu tür kararlar backend ve API geliştirme işimizin bir parçası; kendi projeniz için ikinci bir görüş isterseniz yazabilirsiniz.

İlgili Makaleler

31 Temmuz 2026

API Gateway Nedir? Ne İşe Yarar, Ne Zaman Gerekir?

API gateway'in ne yaptığını, load balancer ve service mesh'ten farkını, ne zaman gerektiğini ve Kong, Traefik ile AWS API Gateway arasında nasıl seçim yapılacağını anlatıyoruz.

Devamını Oku: API Gateway Nedir? Ne İşe Yarar, Ne Zaman Gerekir?
3 Temmuz 2026

gRPC Nedir? REST'ten Farkı ve Ne Zaman Kullanılmalı

gRPC nedir, .proto sözleşmesiyle nasıl çalışır, REST'ten nerede ayrılır? Servisler arasında ne zaman kullanmaya değdiğini, protobuf ile JSON'u karşılaştırdığımız kendi ölçümümüzle anlatıyoruz.

Devamını Oku: gRPC Nedir? REST'ten Farkı ve Ne Zaman Kullanılmalı
24 Nisan 2026

Fintek Yazılım Çözümleri: Türkiye'de Lisans, Defter ve Mutabakat

Fintek kodunun çoğu sıradan yazılım. Zor kısımlar lisansın ve paranın kimde olduğu, bankayla her gün mutabakatı yapılan bir defter ve kart ile kimlik verisini dar bir kapsamda tutmak.

Devamını Oku: Fintek Yazılım Çözümleri: Türkiye'de Lisans, Defter ve Mutabakat