Naar de inhoud
maarten.
Persoon in een tv-regiekamer met meerdere schermen en apparatuur.
Alle stories

SSE of WebSockets voor live updates

Maarten Soetens 12 min lezen

Server-Sent Events en WebSockets kunnen allebei updates vanuit een server direct in een browser tonen, maar hun communicatie en beheer verschillen wezenlijk. Lees hoe beide technieken werken, waar verbindingen in de praktijk vastlopen en welke keuze past bij jouw toepassing.

Wat realtime communicatie in een webapplicatie betekent

De meeste webpagina's reageren alleen op handmatige acties, bijvoorbeeld als je ergens op klikt. Standaard vraagt de browser niet vanzelf of er nieuws is. Bij polling doet de browser dat alsnog, maar dan steeds met vaste tussenpozen. Dat werkt, alleen stuurt de server vaak niets nieuws terug. Hierdoor zie je updates pas met vertraging, terwijl er ondertussen onnodige verzoeken lopen. Bij een echte liveverbinding kan de server z'n update direct doorgeven zodra die er is. Handig als het om dashboards, statuslijsten, notificaties of samenwerken gaat. Dat betekent nog steeds niet dat elk bericht zonder vertraging verschijnt: de route tussen server en browser, drukte, netwerk, proxy's, het beïnvloedt allemaal hoe snel je daadwerkelijk ziet wat er gebeurt. Dus het gaat meestal om de vraag hoe laat een update nog oke is, of onder welke omstandigheden je iets mag missen.

Let ook op de richting: diensten als koersoverzichten blijven vooral luisteren, maar in een gedeelde editor stromen berichten beide kanten op. Niet elk scenario vraagt dus om dezelfde techniek. Wil je voorkomen dat je een protocol kiest puur omdat het 'realtime' heet? Kijk dan eerst wie berichten stuurt, hoe vaak en of een gemiste melding erg is.

Werk je aan de browserkant? Lees meer over front-end development of een freelance developer inhuren voor een webapplicatie.

Hoe Server-Sent Events updates naar de browser sturen

Met Server-Sent Events (SSE) houd je een HTTP-respons langdurig open. Je start dat aan de kant van de browser via EventSource in JavaScript; de server antwoordt met het MIME-type text/event-stream en blijft vervolgens tekstregels doorsturen zolang de verbinding leeft. Een browser kan iedere gebeurtenis opvangen, via de standaard eventlistener of via een handler voor een specifiek event.

Het verkeer is eenrichtingsverkeer: updates gaan alleen van server naar browser. Wil je als gebruiker iets terugsturen? Dat kan gewoon via een aparte HTTP-aanroep, bijvoorbeeld als je een filter instelt of een berichtje verstuurt. Deze strikte scheiding maakt het overzichtelijk: updates via SSE, mutaties via normale API-calls. Omdat SSE gebruikmaakt van standaard HTTP, kun je inspecteren wat er gebeurt op plekken waar je anders gespecialiseerde tooling zou moeten inzetten.

Er zitten wel grenzen aan. SSE stuurt tekst: binaire data moet je zelf encoderen, of via een apart endpoint regelen. De browser probeert te reconnecten na een verbroken verbinding. Met event-ID's kun je het punt aangeven waar je gebleven was, maar de server moet dan wel terug kunnen grijpen op oude gebeurtenissen. Anders pikt de client na reconnect alleen nieuwe meldingen op en kan er wat missen zijn gegaan.

Hoe WebSockets een open tweerichtingsverbinding maken

WebSockets starten via een HTTP-handshake, maar stappen daarna over op een heel eigen protocol over dezelfde TCP-verbinding. Is de handshake klaar, dan kunnen browser en server zonder omweg berichten sturen, beide kanten op, zonder tussenkomst van nieuwe requests. In de browser gebruik je daarvoor de standaard-API, met handlers voor openen, binnenkomende data, sluiten en fouten. Berichten kunnen zowel tekst als binaire data zijn. Dat opent de deur naar live interactie bij bijvoorbeeld games, teken-apps of samen bewerken in één document.

De tweerichtingsverbinding komt goed tot z'n recht als de client constant kleine acties stuurt, zoals muisbewegingen, bewerkingen of spelfragmenten. De server kan dan direct reageren, en ondertussen updates doorgeven van anderen. WebSockets vervangen niet de rest van je applicatie: dingen als inloggen, ophalen van zware gegevens of bestandsupload verlopen meestal toch weer via gewone HTTP. Het aanhouden van één grote verbinding voor alles maakt de boel niet per se onderhoudbaar. Houd dus per deelproces een heldere taakverdeling aan.

Die vrijheid brengt ook meer verantwoordelijkheid. Je moet bepalen hoe berichten eruit zien, hoe ze gecontroleerd worden, en wat je doet als de socket plots ophoudt te werken. Een open verbinding betekent niet dat de applicatiesessie gezond is. Bij een slechte netwerkverbinding kan een socket onmerkbaar afsluiten zonder dat je browser het direct meldt. Heartbeats, tijdslimieten, en reconnects zijn dus stuk voor stuk aandachtspunten in je ontwerp, niet alleen opties van de browser-API. Voor serverwerk met PHP kun je terecht bij een PHP developer.

Eenrichtingsverkeer of tweerichtingsverkeer: het verschil in gebruik

SSE en WebSockets verschillen vooral in de kant op waar data heen mag. Bij SSE komen de updates standaard vanuit de server, richting browser. Als je als gebruiker iets wilt melden, gebruik je een los HTTP-verzoek. WebSockets laten verkeer beide kanten op toe binnen één verbinding. Zegt niets over snelheid of efficiëntie; het maakt enkel complexere interacties mogelijk.

Stel, je bouwt een dashboard met meetwaarden die om de zoveel seconden een update krijgen. Vrijwel alles komt dan van de server naar de client. Daar past SSE goed, en filters kun je met standaard API-aanroepen regelen. Bij een spel, of een samenwerkapp, draait alles juist om het feit dat berichten over en weer zenden mogelijk is. Dan zijn WebSockets vaak de kern van je implementatie. Een chat kun je trouwens met beide technieken bouwen, bijvoorbeeld berichten lezen via SSE en versturen via HTTP, of alles via WebSockets.

Kies wat technisch het beste past bij je verkeer: leg vast hoeveel en hoe vaak iemand iets stuurt, hoe snel een reactie komt en wat er mag gebeuren als een update niet aankomt. Statusinformatie kan meestal gewoon worden overschreven; transacties of bewerkingen moet je apart bevestigen en consistent houden. Dat bepaal je in je protocol, maar óók in je applicatie zelf.

Verbindingen beheren: reconnects, time-outs en sessies

Een SSE- of WebSocket-verbinding blijft open. Maar bij mobiele verbindingen, laptops die in slaapstand gaan, of als je browser tabbladen op de achtergrond parkeert, kan die verbinding toch wegvallen, ook zonder dat je uitlogt of een pagina sluit. Dus de client moet reconnecten, en de server moet oude, verlaten verbindingen uiteindelijk afsluiten.

Reconnecten is functioneel bedoeld als herstel; of de client alle tussenliggende data alsnog krijgt is niet gegarandeerd. SSE ondersteunt hervatten met event-ID's, mits de server weet welke oude events hij moet aanleveren. Bij WebSockets bouw je meestal zelf een systeem voor berichtnummering of synchronisatiepunt. Na reconnect haalt de client vaak eerst de actuele toestand op. Tegelijk werkt het meestal betrouwbaarder om gemiste updates te vervangen door een volledige snapshot, dan alles eindeloos in buffers te houden.

Denk bij de time-outs aan alle lagen, zoals proxy's die open verbindingen na enige tijd zonder verkeer sluiten. SSE kan daar commentaarregels voor gebruiken, WebSockets sturen ping/pong. Te vaak 'kloppen' betekent belasting; te weinig betekent dat je vertraging hebt eer je merkt dat iets kapot is. Ontwerp sowieso je verwerking per bericht idempotent, zodat een mogelijk dubbel verstuurde update geen extra wijziging veroorzaakt. Dan kun je veilig berichten alsnog ontvangen na een storing.

SSE en WebSockets achter proxies en load balancers

SSE en WebSockets lopen vaak via reverse proxies of load balancers voordat ze bij de applicatieserver aankomen. Die tussenlagen zijn soms ingesteld op korte, afgesloten connecties, of bufferen de data voordat het bij je browser uitkomt. Bij SSE zie je daardoor soms meldingen pas als een hele batch aankomt, terwijl de server events allang heeft verzonden. Check in de serverconfiguratie of hij echt kan streamen en data niet vasthoudt tot het in één keer wordt doorgestuurd.

WebSockets werken alleen als de proxy de handshake herkent en keurt, anders behandelt hij het verkeer als gewone HTTP, wat opnieuw kan leiden tot onbedoeld sluiten. Zelfs als alles werkt, kan een reconnect een andere backendserver raken. Gebruik je aan de serverkant lokale sessies, dan kan zo'n reconnect tot verlies van context of abonnement leiden. Probeer sticky sessions waar nodig, maar verwacht daar geen structurele oplossing van: het maakt serverherstel lastiger en kan bij schaalvergroting tot nieuwe problemen leiden.

Bij veel backend-instanties heb je een centrale bus of broker nodig om gebeurtenissen te delen. Zo bereikt een event van server A ook clients die via server B verbonden zijn. Zo'n setup heeft eigen aandachtspunten qua volgorde, dupliceren en vertraging. Kijk niet enkel naar het aantal verbindingen: metingen naar afleververtraging, buffergrootten, reconnects en onverwachts gesloten verbindingen leveren je direct bruikbare informatie op.

Authenticatie en beveiliging van live verbindingen

Een liveverbinding kan uren of langer actief blijven. Dus de server moet weten welke gebruiker bij een verbinding hoort en welke rechten daarbij gelden, óók als die rechten tussentijds veranderen. Via SSE is het niet standaard mogelijk eigen headers toe te voegen. Dat betekent dat authenticeren meestal via cookies gebeurt, met de beperkingen van browserbeleid op het gebied van cross-originverkeer en herkomstcontrole. Een token meegeven in de URL lijkt makkelijk, maar komt in logs, browsergeschiedenis of monitoring terecht, wat je wilt vermijden.

Bij WebSockets geldt hetzelfde: authenticatie gaat over de handshake, vaak met cookies; de Origin-header moet je altijd controle ren, want niet iedere browseraanroep is te vertrouwen. Na het connecteren controleert de server ieder binnenkomend bericht apart. Een verbond gebruiker is niet vanzelf bevoegd om alles via die verbinding aan te spreken.

Let ook op veranderende rechten. Wordt een sessie ingetrokken, of raak je als gebruiker je rechten kwijt tijdens een open verbinding? Beslis of je dan actief sluit, of bij ieder bericht je rechten opnieuw checkt. Breng limieten aan op berichtgrootte, frequentie en verbindingen per account. Het ontbreken van grenzen zorgt er anders voor dat foute clients of misbruik de boel vast kunnen zetten.

Backpressure en berichtenstromen onder belasting

Er zijn situaties waarin een server vaker nieuwe berichten aanmaakt dan een browser kan verwerken. Een browser die op de achtergrond draait, of even 'hangt', kan snel achterlopen. Blijft alles bufferen, dan stijgt het geheugengebruik per verbinding. Als je veel verbindingen tegelijk openhoudt, groeit dit uit tot een serieus schaalprobleem. Dus moet je als ontwikkelaar bepalen wat er gebeurt als clients niet bij kunnen houden.

Niet elk bericht is even belangrijk. Sla je alleen meetwaarden of statuspunten door? Dan kun je overwegen om alleen de nieuwste waarde te bewaren, zodat oude updates overschreven worden. Maar als je transacties, berichten of gebeurtenissen uitwisselt, is geen enkel verlies acceptabel. Opslag van events, volgorde en het kunnen hervatten vanaf een punt zijn dan belangrijker dan alleen 'het meest actuele' tonen. Je protocol kan naast de hoofdstroom een aparte, compacte status-updatestroom bieden, terwijl echt belangrijke events in een robuust opslagkanaal terechtkomen.

Maak backpressure zichtbaar: houd wachtrijen, bufferlengte en clients die structureel te laat zijn in de gaten. Beslis wat er gebeurt bij vertraging: berichten samenvoegen, verbindingen sluiten, of een client dwingen opnieuw vanaf een actuele momentopname te synchroniseren. Heb je geen afspraak, dan bepaalt het bufferslot wat er uiteindelijk verloren gaat, en dat merk je vaak pas als de boel al zwaar belast is. Test dus met tragere clients en tijdens piekbelasting, niet alleen op de snelste werkplek.

Veelgestelde vragen

Hoe stuur ik databasewijzigingen door naar een SSE- of WebSocket-client?

Stuur databasewijzigingen niet rechtstreeks naar iedere open verbinding. Koppel in plaats daarvan zulke wijzigingen aan een centrale gebeurtenissenstroom waarop live verbonden clients kunnen abonneren. Als elke client zelfstandig de database checkt, leidt dat tot veel belasting en geen betrouwbare updates.

Vaak publiceert de applicatie een gebeurtenis direct na een succesvolle wijziging. Eventueel kan een message broker deze gebeurtenis verdelen. Wil je zeker weten dat een event nooit verloren gaat als de databasewijziging slaagt maar publiceren mislukt, gebruik dan een transactional outbox: beide acties worden samen opgeslagen, waarna een achtergrondproces de gebeurtenis alsnog verzendt naar de clients.

Hoe gebruik ik SSE of WebSockets in een React-app zonder dubbele verbindingen?

Je voorkomt dubbele verbindingen door de SSE- of WebSocket-verbinding centraal te beheren. Sluit de verbinding zodra een component die hem gebruikte onnodig wordt. Laat je elke component afzonderlijk een EventSource of socket openen? Dan krijg je ongewenst meerdere verbindingen per gebruiker en mogelijk dubbel verzonden updates.

Gebruik in React een effect voor het openen en sluiten van de verbinding. Heb je data die door meerdere componenten wordt gebruikt, plaats die dan in een context of deelbare clientmodule, niet per component. Let op her-renderen: veranderende objecten of nieuwe functies kunnen het effect onbedoeld opnieuw activeren. Controleer in ontwikkeling of oude verbindingen niet blijven bestaan na navigatie of componentverwijdering.

Hoeveel SSE-verbindingen kan een browser tegelijk openhouden?

Daar is geen universele grens voor; het hangt af van browsertype en netwerk. Bij HTTP/1.1 hanteren browsers vaak een eerder beperkte limiet per domein. Zes verbindingen zie je vaak terug, maar het kan afwijken. HTTP/2 maakt dat anders: daar kunnen meer streams over dezelfde verbinding lopen, waarbij de browser en server samen bepalen hoeveel tegelijk open mogen zijn.

Denk dus niet dat elk dashboard of widget z'n eigen SSE-verbinding kan openen zonder problemen. Bundel waar mogelijk verbindingen, laat componenten zich abonneren op events uit een gedeelde stroom, en sluit ongebruikte connecties. Test zelf met meerdere tabbladen en browsers die je gebruikers echt inzetten.

Hoe test ik of live updates betrouwbaar blijven werken na een netwerkstoring?

Het antwoord is simpel: test niet alleen bij goed netwerk, maar onderbreek bewust tijdens je test het netwerk, of sluit verbindingen via de server hard af. Simuleer een client die langere tijd niet reageert. Let daarna op: bouwt de client weer verbinding op, en ontvangt die alles wat nodig is?

Test ook uitzonderingen: komen berichten dubbel binnen, in de verkeerde volgorde, of met vertraging? Geautomatiseerde tests zijn mogelijk door serverreacties of de transportlaag te vervangen door een testomgeving. Controleer tenslotte of afgesloten componenten geen nieuwe events verwerken, en reconnectpogingen niet eindeloos doorgaan.

Hoe voorkom ik dat live updates in mijn webapplicatie verouderde gegevens tonen?

Gebruik versienummers of volgordetellers in je updates en laat de client oudere berichten negeren. Een enkel tijdstip volstaat soms, maar als klokken niet gelijk lopen is een monotoon oplopende teller betrouwbaarder.

Na reconnect kan de client controleren of er een gat zit tussen updates; zijn events niet terug te halen, dan haalt de client een nieuwe momentopname op. Maak berichtverwerking idempotent, zodat dezelfde update meerdere keren verwerken geen dubbel effect heeft. Zo blijft wat je in beeld krijgt altijd overeenkomen met de laatste stand, ook wanneer enkele berichten onderweg zijn verdwenen.

Foto: Tahir Xəlfəquliyev

Portret van Maarten

Maarten

Freelance developer in Nijmegen

Even kennismaken?

Vertel kort wat er speelt. Dan hoor je wat er kan, wat ik anders zou doen en waar AI bij jou wél en niet iets toevoegt. Vrijblijvend.

Het kantoor in Nijmegen
© 2026 maarten.online Sitemap Privacy Algemene voorwaarden
Het kantoor in Nijmegen

Maarten.

Freelance developer in Nijmegen. Liever direct contact? Dat kan ook.

Kennismaken

Laat je gegevens achter, dan kijken we of het klikt. Vrijblijvend en zonder verkooppraat.

Maarten

Stuur een bericht via WhatsApp

Hoi! Waar kan ik je mee helpen?

nu