{"canonical_url":"https://engineer.company/sv/glossary/server-sent-events/","content_markdown":"# Server-sent events\n\n## Vad det är\n\nServer-sent events är ett sätt för en webbserver att skicka meddelanden till en\nsida genom ett vanligt HTTP-svar, som servern håller öppet och skriver i varje\ngång det finns något nytt. De definieras i HTML-standarden, som WHATWG\nunderhåller, och den beskriver både textformatet för strömmen och `EventSource`,\ngränssnittet i webbläsaren som läser strömmen. Namnet förkortas ofta SSE, och\nformatet kallas ofta efter sin medietyp, `text/event-stream`.\n\nEn sida öppnar en ström med en enda rad, `new EventSource(url)`. Webbläsaren\nskickar en `GET`-begäran, som kan ha med sig `Accept: text/event-stream`, och\nväntar sig ett svar med status 200 och den innehållstypen. Sedan skickar servern\nsina headrar men gör aldrig klart svaret. Varje gång något händer skriver den\nnågra rader text, och webbläsaren gör om varje block av rader till en händelse\nsom sidan kan lyssna efter.\n\nFormatet är medvetet enkelt. En ström är alltid UTF-8, och varje rad är ett\nfält. En `data`-rad bär innehållet, och flera `data`-rader i följd sätts ihop\nmed radbrytningar. En `event`-rad ger händelsen en typ, och utan den är typen\n`message`. En `id`-rad sätter id:t för den senaste händelsen, och en `retry`-rad\nanger hur många millisekunder webbläsaren väntar innan den ansluter igen. En rad\nsom börjar med kolon är en kommentar, som webbläsaren ignorerar. En tom rad\navslutar blocket och skickar i väg händelsen, så ett block som avbryts före sin\ntomma rad kastas.\n\nÅteranslutning är en del av standarden. När anslutningen bryts väntar\nwebbläsaren under återanslutningstiden, som börjar på ett värde som webbläsaren\nsjälv väljer, enligt standarden troligen några sekunder, och skickar sedan\nbegäran på nytt. Har servern gett sina händelser id:n har den nya begäran med\nsig det senaste av dem i headern `Last-Event-ID`, och servern kan fortsätta\ndärifrån. Vissa svar avslutar i stället strömmen för gott: en annan status än\n200 eller en annan innehållstyp får webbläsaren att ge upp och sluta försöka,\noch standarden pekar ut 204 No Content som sättet för en server att säga att\nströmmen är slut.\n\nRiktningen går bara åt ett håll. Efter den första begäran går ingenting från\nsidan till servern över den anslutningen; när sidan har något att säga skickar\nden en egen HTTP-begäran.\n\n## Varför det spelar roll\n\nMånga funktioner som ser levande ut behöver bara en riktning: förloppet i ett\nlångt jobb, ett nytt meddelande, en siffra på en dashboard, ett svar som kommer\ni delar. Utan en ström måste sidan fråga om och om igen, så kallad polling. Den\nfrågar med några sekunders mellanrum, de flesta svaren säger att ingenting har\nändrats, och nyheter väntar upp till ett helt intervall innan någon ser dem. Med\nen ström skriver servern i samma ögonblick som något händer.\n\nDet vanliga alternativet för att skicka data till en sida är WebSocket, som\nbyter över anslutningen från HTTP till ett eget protokoll. Server-sent events\nhåller sig till HTTP från början till slut, så de passerar samma proxyer och\nlastbalanserare som vilken annan begäran som helst, de använder samma cookies\noch samma regler för begäranden mellan olika ursprung, och de kan dela en\nHTTP/2-anslutning med resten av sidan. Återanslutning och återupptagning från\nden senaste händelsen följer med webbläsaren i stället för att vara kod som\nvarje team skriver själv. WebSocket är fortfarande rätt val när klienten har\nlika mycket att säga som servern, som i en chatt eller en delad editor.\n\nFormatet är inte heller bundet till webbläsaren. Vilken HTTP-klient som helst\nkan läsa det, och specifikationer utanför webben använder det. I Model Context\nProtocol, som AI-agenter anropar verktyg genom, låter transporten Streamable\nHTTP en server svara på en begäran antingen med ett enda JSON-objekt eller med\nett `text/event-stream`-svar. På den strömmen kan servern skicka notifieringar\noch egna begäranden före det slutliga svaret, och den kan sätta id:n på\nhändelserna, så att en klient som tappar anslutningen kan fortsätta med\n`Last-Event-ID`. Streamable HTTP ersatte HTTP+SSE, transporten i den tidigare\nprotokollversionen 2024-11-05.\n\nBegränsningarna är värda att känna till innan man väljer det. Strömmen bär bara\ntext, så binära data måste först kodas som text. Webbläsarens\n`EventSource`-konstruktor tar en URL och en enda inställning, `withCredentials`,\noch ingenting annat, så en sida kan inte lägga till en `Authorization`-header i\nbegäran.\n\n## Så ser det ut i praktiken\n\nUtbytet nedan följer ett långt exportjobb. Webbläsaren har tappat anslutningen\nefter händelse 41 och ansluter igen, så begäran har med sig det id:t, och\nservern fortsätter från händelse 42:\n\n```http\nGET /jobs/4471/events HTTP/1.1\nHost: example.com\nAccept: text/event-stream\nLast-Event-ID: 41\n\nHTTP/1.1 200 OK\nContent-Type: text/event-stream\nCache-Control: no-store\n\nretry: 5000\n\n: still working\n\nid: 42\nevent: progress\ndata: {\"done\": 120, \"total\": 400}\n\nid: 43\nevent: progress\ndata: {\"done\": 400, \"total\": 400}\n\nid: 44\nevent: finished\ndata: {\"report\": \"/jobs/4471/report.pdf\"}\n\n```\n\n`retry`-raden ber webbläsaren vänta fem sekunder före varje senare\nåteranslutning, och kommentarraden bär ingen händelse alls; den finns där för\natt hålla anslutningen aktiv medan jobbet är tyst. Sidan lyssnar efter de två\nhändelsetyperna vid namn:\n\n```js\nconst source = new EventSource(\"/jobs/4471/events\");\nsource.addEventListener(\"progress\", (event) =\u003e {\n  const { done, total } = JSON.parse(event.data);\n  showProgress(done / total);\n});\nsource.addEventListener(\"finished\", (event) =\u003e {\n  showReport(JSON.parse(event.data).report);\n  source.close();\n});\nsource.addEventListener(\"error\", () =\u003e {\n  if (source.readyState === EventSource.CLOSED) showRetryButton();\n});\n```\n\nAnropet till `close()` spelar roll. När servern avslutar ett svar på vanligt\nsätt behandlar webbläsaren det som en bruten anslutning och ansluter igen, så\nutan anropet skulle en ström för ett färdigt jobb öppnas igen efter fem\nsekunder. `error`-hanteraren skiljer mellan de två sorternas fel: så länge\n`readyState` är `CONNECTING` försöker webbläsaren fortfarande, och när den är\n`CLOSED` har den gett upp.\n\nArbete som fortsätter efter att agenten har fått sitt svar är ett av ämnena på\nsidan om [din programvara som verktyg för AI-agenter](/sv/ai-tools/) här på\nwebbplatsen. Den beskriver hur varje operation som en agent ska ha tillgång till erbjuds som\nett verktyg, med en MCP-server som erbjuder samma operationer till de agenter\nsom talar det protokollet, och hur tidskrävande arbete flyttas till en kö så att\nagenten får ett svar medan arbetet fortsätter. I MCP-specifikationen kan en\nserver använda en händelseström som den ovan för att skicka egna förfrågningar\neller notifieringar före det slutliga svaret på klientens förfrågan.\n\n## Var det går fel\n\n**Händelser som kommer i klumpar, eller alla på en gång i slutet.** Något mellan\nservern och webbläsaren håller tillbaka svaret. nginx, till exempel, buffrar som\nstandard svaren från servern bakom sig och skickar bara vidare ett svar\nallteftersom det kommer när buffring är avstängd. HTML-standarden varnar också\nför att HTTP-chunking som utförs av ett lager som inte känner till tidpunkterna\ni strömmen kan göra den opålitlig. Stäng av buffring för strömmens location, i\nnginx med `proxy_buffering off` eller med headern `X-Accel-Buffering: no` i\nsvaret, töm skrivbufferten efter varje händelse i serverkoden, och testa genom\nhela kedjan, proxyn inräknad, i stället för mot servern ensam.\n\n**Tysta strömmar som kapas av en timeout.** En proxy som inte ser en enda byte\npå ett tag utgår från att anslutningen är död. I nginx är standardvärdet för\n`proxy_read_timeout` 60 sekunder mellan två läsningar, och därefter stängs\nanslutningen, och HTML-standarden varnar för att vissa äldre proxyer bryter\nanslutningar efter en kort timeout. Den föreslår en kommentarrad ungefär var\n15:e sekund, som kostar några få byte och som webbläsaren ignorerar.\n\n**Händelser som försvinner vid en återanslutning.** Webbläsaren skickar bara\n`Last-Event-ID` om servern har gett sina händelser id:n, och headern hjälper\nbara om servern fortfarande kan hitta det som kom efter det id:t. Ge varje\nhändelse ett id som fungerar som en markör i strömmen, behåll ett fönster med de\nsenaste händelserna som kan spelas upp igen, och skicka hela det aktuella\ntillståndet när ett id är för gammalt att fortsätta från. MCP-specifikationen\nlägger till en regel som är värd att kopiera: id:n hör till en enda ström, och\nen server får inte spela upp meddelanden på en ström när de var avsedda för en\nannan.\n\n**Återanslutning som aldrig slutar, eller slutar för gott.** En ström som\navslutas normalt kommer tillbaka efter återanslutningstiden, om och om igen, så\nett färdigt jobb fortsätter att öppna sin ström på nytt om inte sidan anropar\n`close()` eller servern svarar på återanslutningen med 204. Det motsatta händer\nunder en driftsättning. En proxy som svarar 502 eller 503 medan servrarna\nstartar om ger varje öppen `EventSource` en annan status än 200, och varenda en\nav dem slutar för gott. Lyssna efter `error`, och när `readyState` är `CLOSED`,\nskapa en ny `EventSource` efter en slumpmässig fördröjning som växer för varje\nfel.\n\n**För många strömmar till en webbläsare.** Webbläsare begränsar hur många\nanslutningar de håller öppna till en server, och en ström över HTTP/1.1 upptar\nen av dem så länge den pågår. HTML-standarden varnar för att en webbplats där\nvarje öppen sida har sin egen `EventSource` kan slå i den gränsen. Leverera\nströmmen över HTTP/2, där strömmar delar en anslutning och RFC 9113\nrekommenderar att minst 100 tillåts samtidigt, eller dela en enda `EventSource`\nmellan flikarna genom en shared worker.\n\n**En token i adressen.** Eftersom `EventSource` inte kan skicka en\n`Authorization`-header blir den snabba lösningen en token i URL:en, där omvända\nproxyer och åtkomstloggar skriver ner den. Autentisera strömmen med sessionens\ncookie, som sidan redan har, och lägg till `withCredentials` när strömmen kommer\nfrån ett annat ursprung, eller med en kortlivad engångsbiljett som sidan hämtar\nmed en autentiserad begäran precis innan den öppnar strömmen.\n\n## Läs mer\n\n- [HTML Standard: Server-sent events](https://html.spec.whatwg.org/multipage/server-sent-events.html)\n  — formatet för strömmen, gränssnittet `EventSource`, återanslutning och\n  standardens anmärkningar till författare om proxyer och gränser för antalet\n  anslutningar.\n- [Transports - Model Context Protocol](https://modelcontextprotocol.io/specification/2025-06-18/basic/transports)\n  — Streamable HTTP, där en server kan svara med en händelseström, och hur en\n  avbruten ström återupptas.\n- [RFC 9113: HTTP/2](https://www.rfc-editor.org/rfc/rfc9113) — strömmar som\n  delar en anslutning, och inställningen som begränsar hur många som kan vara\n  öppna samtidigt.\n- [nginx: Module ngx_http_proxy_module](https://nginx.org/en/docs/http/ngx_http_proxy_module.html)\n  — `proxy_buffering`, headern `X-Accel-Buffering` och `proxy_read_timeout`.\n\n\u003chttps://engineer.company/sv/glossary/server-sent-events/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hur en server håller ett HTTP-svar öppet och skriver händelser i det, vad webbläsaren gör när anslutningen bryts, och proxyerna som håller tillbaka dem.","formats":{"gemtext":"https://engineer.company/sv/glossary/server-sent-events/index.gmi","gopher":"https://engineer.company/sv/glossary/server-sent-events/gophermap","html":"https://engineer.company/sv/glossary/server-sent-events/","json":"https://engineer.company/sv/glossary/server-sent-events/index.json","markdown":"https://engineer.company/sv/glossary/server-sent-events/index.md","pdf":"https://engineer.company/sv/glossary/server-sent-events/index.pdf"},"kind":"page","language":"sv","title":"Vad är server-sent events?","url":"https://engineer.company/sv/glossary/server-sent-events/","version":1}