# WebSocket för webbapplikationer – realtidskommunikation i webbläsaren

*Annette Härröd*
*20 november 2026*

> Lär dig hur WebSocket ger webbapplikationer tvåvägskommunikation i realtid, och hur du kommer igång med WebSocket API i JavaScript.

# WebSocket för webbapplikationer – realtidskommunikation i webbläsaren

WebSocket är ett kommunikationsprotokoll som gör det möjligt för en webbläsare och en server att skicka data till varandra i realtid, utan att sidan behöver laddas om eller att webbläsaren hela tiden frågar servern om det finns något nytt. Protokollet är standardiserat av IETF i RFC 6455 och stöds av alla stora webbläsare. Den här artikeln förklarar vad WebSocket är, hur det skiljer sig från vanlig HTTP, och hur du använder WebSocket API i JavaScript.

## Vad är WebSocket?

WebSocket är ett protokoll för full-duplexkommunikation över ett enda TCP-anslutning. Full-duplex betyder att både klienten (webbläsaren) och servern kan skicka meddelanden till varandra oberoende av varandra, när som helst. Det är precis som ett telefonsamtal: båda parter kan prata och lyssna samtidigt.

Detta skiljer WebSocket från den traditionella webbkommunikationen, där webbläsaren alltid tar initiativet. En webbsida begär en sida, servern svarar, och anslutningen stängs. För att ta reda på om det finns nya data måste webbläsaren göra en ny begäran. Med WebSocket hålls anslutningen öppen, och servern kan skicka data till webbläsaren så fort något händer – utan att webbläsaren har bett om det.

Protokollet använder adresserna ws:// för okrypterade anslutningar och wss:// för krypterade anslutningar (motsvarande http och https).

## Hur WebSocket skiljer sig från HTTP

HTTP är byggt kring begäran-svar. Webbläsaren skickar en begäran, servern bearbetar den och skickar tillbaka ett svar. Sedan är samtalet över. Om webbplatsen behöver veta om nya meddelanden har kommit, måste den fråga servern om och om igen. Det kallas polling, och det slösar på både bandbredd och batteri.

WebSocket fungerar annorlunda. Anslutningen börjar som en vanlig HTTP-begäran, men om både webbläsare och server stöder WebSocket, uppgraderas anslutningen till ett WebSocket-protokoll. Efter uppgraderingen finns det en beständig anslutning som båda parter kan använda för att skicka meddelanden när som helst.

För appar som behöver uppdateringar i realtid – chatt, aktiekurser, sportresultat, samarbetsverktyg – är WebSocket betydligt effektivare än upprepad polling.

## WebSocket-handshake

Innan ett WebSocket-anslutning kan användas, måste den upprättas genom en så kallad handshake. Stegen ser ut så här:

1. Webbläsaren skickar en vanlig HTTP-förfrågan till servern, med särskilda rubriker som ber servern att uppgradera anslutningen till WebSocket.
2. Servern svarar med statuskod 101 Switching Protocols om den accepterar uppgraderingen.
3. Från och med nu används WebSocket-protokollet över samma TCP-anslutning.

Handshaken innebär att WebSocket kan köras över samma portar som vanlig webbtrafik (80 och 443), vilket gör att det fungerar bakom de flesta brandväggar och proxyservrar utan särskild konfiguration.

## WebSocket API i JavaScript

Alla moderna webbläsare har ett inbyggt WebSocket-objekt i JavaScript. Det är det gränssnitt du använder för att öppna en anslutning, skicka och ta emot meddelanden.

Så här öppnar du en anslutning:

```javascript
const socket = new WebSocket('wss://exempel.se/socket');
```

När anslutningen är öppen kan du lyssna på händelser. `open` utlöses när anslutningen är redo, `message` när servern skickar data, `error` om något går fel, och `close` när anslutningen stängs.

```javascript
socket.addEventListener('open', () => {
  console.log('Ansluten');
  socket.send('Hej från webbläsaren');
});

socket.addEventListener('message', (event) => {
  console.log('Meddelande från servern:', event.data);
});

socket.addEventListener('close', () => {
  console.log('Anslutning stängd');
});
```

För att skicka data använder du `socket.send()`. Du kan skicka ren text eller binär data som Blob eller ArrayBuffer. Meddelandet som kommer tillbaka hamnar i `event.data`.

## När ska du använda WebSocket?

WebSocket är inte rätt val för allt. En vanlig webbplats som laddar artiklar och bilder klarar sig utmärkt med vanlig HTTP. WebSocket är särskilt användbart i följande situationer:

- Chatt- och meddelandeappar där meddelanden ska visas direkt
- Samarbetsverktyg där flera personer redigerar samma dokument samtidigt
- Spel i webbläsaren där spelarnas handlingar måste synkroniseras snabbt
- Ticker- och dashboard-sidor med aktiekurser, väder eller sportresultat som uppdateras löpande
- Notifikationer som ska nå användaren omedelbart

Om ditt behov är att då och då hämta nya data – till exempel ladda nästa sida i ett flöde – räcker det gott med vanliga fetch-anrop. Läs mer om det i vår guide till [Fetch API JavaScript](/artiklar/fetch-api-javascript).

## Säkerhet: wss:// och autentisering

Använd alltid wss:// (WebSocket Secure) i stället för ws:// på produktion. wss:// krypterar anslutningen med TLS, precis som https krypterar http. Utan kryptering kan den som lyssnar på nätverket läsa allt som skickas över WebSocket-anslutningen.

Autentisering sker inte automatiskt i WebSocket-protokollet. Du måste själv se till att bara behöriga användare kan ansluta. Ett vanligt sätt är att skicka en token i anslutningsadressen eller i det första meddelandet efter att anslutningen öppnats, och låta servern kontrollera den innan några känsliga data skickas.

## Vanliga fel och felsökning

- Anslutningen kopplas direkt: servern stöder inte WebSocket, eller så blockerar en brandvägg porten.
- Meddelanden kommer inte fram: kontrollera att både `send` och `message`-lyssnaren är på plats, och att servern faktiskt skickar tillbaka data.
- Anslutningen bryts vid inaktivitet: vissa proxyservrar stänger anslutningar som inte används. En lösning är att skicka regelbundna “ping”-meddelanden för att hålla anslutningen vid liv.
- CORS gäller inte på samma sätt för WebSocket som för vanliga HTTP-anrop, men servern måste ändå acceptera anslutningen från din domän.

## Kom igång med WebSocket

WebSocket är ett kraftfullt verktyg för webbapplikationer som behöver kommunikation i realtid. Det är väl stödd i webbläsare, enkelt att komma igång med via JavaScript API, och betydligt effektivare än upprepad polling för uppdateringar som ska nå användaren direkt.

Börja med att öppna en anslutning till en testserver, skicka ett meddelande och se hur servern svarar. När du förstår grunderna – handshake, händelser och meddelandeformat – är du redo att bygga appar som reagerar i realtid.
