{"canonical_url":"https://engineer.company/es/glossary/websocket/","content_markdown":"# WebSocket\n\n## Qué es\n\nWebSocket es un protocolo para una conexión en la que ambas partes pueden\nescribir en cualquier momento. Un intercambio inicial HTTP la establece, y\npermanece abierta hasta que una de las partes la cierra o la conexión falla.\nEl IETF lo publicó como RFC 6455 en diciembre de 2011. La parte que el\nnavegador ofrece a los scripts, el objeto `WebSocket`, está definida en\nWebSockets Standard de WHATWG. En código y documentación también se escribe\n«websocket» o «web socket», y el plural WebSockets suele referirse a la\ntecnología en su conjunto.\n\nEn el intercambio inicial clásico de HTTP/1.1, la conexión empieza con un\n`GET` ordinario. El cliente añade `Upgrade:\nwebsocket` y `Connection: Upgrade`, un `Sec-WebSocket-Version` de 13 y un\n`Sec-WebSocket-Key`: un valor aleatorio de 16 bytes codificado en base64.\nUn servidor que acepta responde con el estado 101 Switching Protocols y una\ncabecera `Sec-WebSocket-Accept`. Su valor demuestra que el servidor ha leído\nprecisamente ese intercambio, en lugar de reproducir una respuesta antigua:\nes la clave del cliente con un GUID fijo añadido, procesada con SHA-1 y\ncodificada en base64. Desde ese momento termina HTTP en esa conexión y las\ndos partes intercambian tramas. En cambio, HTTP/2 y HTTP/3 transportan\nWebSocket por un único flujo mediante CONNECT extendido, como especifican\nRFC 8441 y RFC 9220.\n\nUna trama es pequeña. Su cabecera empieza en dos bytes, crece en dos u ocho\nmás cuando la carga supera los 125 bytes y añade otros cuatro en las tramas\ndel cliente, que llevan una clave de enmascaramiento. Cada trama lleva un\ncódigo de operación: texto, datos binarios o continuación de un mensaje\nrepartido entre varias tramas; otros tres códigos corresponden a las tramas\nde control de cierre, ping y pong. Un mensaje de texto completo debe ser UTF-8 válido; un\nfragmento individual puede dividir una secuencia UTF-8. Cada trama que envía\nel cliente se enmascara con una nueva clave aleatoria de 32 bits, y el\nservidor nunca enmascara. El enmascaramiento no es cifrado. Existe para impedir que un\nscript hostil elija los bytes exactos que cruzan la red y los use para\ncontaminar la caché de algún proxy situado en el camino.\n\nLas direcciones usan los esquemas `ws://` y `wss://`, con los puertos 80 y\n443 como valores predeterminados, y `wss` ejecuta todo el intercambio dentro\nde TLS. Son los puertos que ya utiliza HTTP, y es deliberado: para los\ncortafuegos y proxies por los que pasa, el intercambio inicial parece una\npetición web cualquiera.\n\n## Por qué importa\n\nCon respuestas HTTP cortas, el servidor solo habla cuando se le pregunta.\nMuchos productos necesitan lo contrario: un mensaje de chat, un precio que\nacaba de cambiar, un cursor en un documento compartido o una tarea en segundo\nplano que ha terminado. Sin un canal por el que pueda escribir el servidor,\nel cliente tiene que realizar sondeos. Pregunta cada pocos segundos; la\nmayoría de las respuestas solo dice que nada ha cambiado, cada una lleva un\njuego completo de cabeceras y las novedades esperan hasta un intervalo antes\nde que alguien las vea. Una conexión WebSocket abierta elimina ambos costes.\nEl servidor puede enviar cuando ocurre algo, sin esperar al siguiente\nsondeo. Cada mensaje solo necesita unos pocos bytes de estructura de trama\nen lugar de un juego completo de cabeceras HTTP.\n\nEl precio es mantener estado. Una petición HTTP puede llegar a cualquier\nservidor situado detrás de un balanceador de carga, mientras que una conexión\nWebSocket pertenece a un proceso durante toda su vida. Ese proceso reserva\nmemoria para cada conexión abierta; un despliegue o reinicio las corta todas\na la vez, y cada proxy y balanceador del camino debe admitir el intercambio\ninicial y tolerar una conexión que puede permanecer en silencio durante\nminutos. Usar más de un servidor plantea una pregunta que HTTP ordinario no\nhace: cuando sucede algo en el servidor A, ¿cómo llega a un cliente cuya\nconexión está en el servidor B? La respuesta habitual es un canal compartido\nde publicación y suscripción que escuchan todos los servidores. Eso añade\notro sistema que mantener en funcionamiento.\n\nPor eso es una elección, no la opción predeterminada. Cuando solo el servidor\ntiene novedades que enviar, los eventos enviados por el servidor, definidos\nen HTML Standard, transmiten eventos mediante una respuesta HTTP ordinaria\nde tipo `text/event-stream`, y el navegador se reconecta por sí solo cuando\nla respuesta se interrumpe. WebSocket justifica sus componentes adicionales\ncuando el cliente tiene tanto que decir como el servidor, como en los chats,\nlos juegos y la edición colaborativa.\n\n## Cómo se aplica en la práctica\n\nEl intercambio siguiente abre una conexión de chat. La clave es el valor de\nejemplo del propio RFC 6455, y el valor de aceptación es el que muestra el\nestándar y que todo servidor correcto debe devolver para esa clave.\n\n```http\nGET /chat HTTP/1.1\nHost: example.com\nUpgrade: websocket\nConnection: Upgrade\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\nSec-WebSocket-Version: 13\nOrigin: https://example.com\n\nHTTP/1.1 101 Switching Protocols\nUpgrade: websocket\nConnection: Upgrade\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\n```\n\nDespués de la línea en blanco que termina la respuesta del servidor, nada\nde lo que circula por esa conexión sigue siendo HTTP. El navegador realiza\ntodo el intercambio inicial con una llamada al constructor y deja el resto\na los escuchadores de eventos:\n\n```js\nconst socket = new WebSocket(\"wss://example.com/chat\");\nsocket.addEventListener(\"open\", () =\u003e socket.send(\"hello\"));\nsocket.addEventListener(\"message\", (event) =\u003e console.log(event.data));\nsocket.addEventListener(\"close\", (event) =\u003e {\n  console.log(event.code, event.reason, event.wasClean);\n});\n```\n\nEl evento de cierre indica cómo terminó la conexión. El código 1000 es un\ncierre normal, y el 1001 significa que una de las partes se marcha, como un\nservidor que se apaga o un navegador que abandona la página. El código 1006\nsignifica que la conexión se cortó sin ninguna trama de cierre. Ninguno de\nlos extremos puede enviarlo: solo existe para que el programa que utiliza\nel protocolo distinga una terminación anormal de una limpia.\n\nLa diferencia entre el modelo de petición y respuesta y un socket se ve con\nclaridad en un proyecto del portafolio de este sitio. Al migrar una API a\nHuma v2, [todas las rutas pasaron al modelo de petición y respuesta de Huma\nsalvo exactamente dos](/es/portfolio/migrated-the-api-to-huma-v2-at-100-parity/):\nlos puntos de conexión WebSocket siguieron directamente sobre Fiber, porque\nallí el código necesita realmente el socket y el modelo de Huma no encaja.\nUn framework construido sobre la estructura de HTTP describe y valida bien\npeticiones y respuestas; una conexión bidireccional de larga duración es\nsencillamente otra cosa.\n\n## Dónde surgen los problemas\n\n**Una página de otro sitio abre una conexión con las cookies de sus\nvisitantes.** El navegador envía la petición de intercambio inicial al\nhost del servidor y puede incluir las cookies de ese host, de acuerdo con las políticas de cookies\ndel navegador. Si esas políticas permiten peticiones autenticadas entre\nsitios, un servidor que autentica mediante cookies e ignora la cabecera\n`Origin` puede aceptar una conexión abierta por una página de otro sitio en\nnombre del visitante. RFC 6455 indica que un servidor destinado solo a\nciertos sitios debería comparar `Origin` con los esperados y rechazar los\ndemás con 403 Forbidden. Hágalo durante el intercambio inicial, antes de\naceptar la conexión.\n\n**El token de acceso termina en los registros.** El constructor `WebSocket`\ndel navegador solo acepta una URL y una lista opcional de subprotocolos, de\nmodo que un script no puede añadir una cabecera `Authorization`. El atajo es\nponer un token en la URL, donde los proxies inversos y los registros de\nacceso lo anotan. El RFC deja abierta la autenticación y menciona como\nopciones las cookies, la autenticación HTTP y la autenticación TLS. Funciona\nuna cookie con la comprobación de `Origin` anterior, y también un pase de un\nsolo uso y corta duración que la página obtiene mediante una llamada HTTP\nautenticada y consume en el intercambio inicial.\n\n**Un reinicio convierte a todos los clientes en una avalancha.** Un\ndespliegue abrupto o un reinicio puede cerrar todas las conexiones a la vez.\nLos clientes que no reciben una trama de cierre notifican el código 1006;\nsi todos se reconectan inmediatamente y siguen intentándolo, el servidor\nvuelve a arrancar ante lo que el RFC compara con un ataque de denegación de\nservicio. RFC 6455 pide que los clientes esperen un tiempo aleatorio antes\ndel primer intento, sugiere entre 0 y 5 segundos y solicita aumentar la\nespera tras cada fallo, por ejemplo mediante retroceso exponencial binario\ntruncado. Un servidor que cierra sus conexiones con 1001 antes de detenerse\nal menos comunica a los clientes que la interrupción estaba prevista.\n\n```js\nfunction reconnectDelay(attempt) {\n  if (attempt === 0) return Math.random() * 5000;\n  const ceiling = Math.min(60_000, 1000 * 2 ** attempt);\n  return Math.random() * ceiling;\n}\n```\n\n**Las conexiones mueren y nadie lo advierte.** Una conexión sin tráfico no\nda a ninguna parte una señal de que el camino siga existiendo. Un extremo\nque desaparece sin trama de cierre parece igual que uno silencioso hasta\nque falla la siguiente escritura. Para eso existen ping y pong: un extremo\ndebe responder a un ping con un pong, salvo que ya haya recibido una trama\nde cierre. Si varios pings siguen sin respuesta, puede contestar solo al\núltimo. El RFC señala que un ping sirve para mantener viva la conexión o\ncomprobar que la otra parte aún responde. La API del navegador no permite\nenviar un ping, por lo que el temporizador corresponde al servidor: envíe\npings a cada conexión a intervalos fijos y cierre las que no respondan con\nsu pong.\n\n**Un mensaje consume toda la memoria del servidor.** El campo de longitud\nde la cabecera de una trama admite cargas mucho mayores que la memoria de\ncualquier servidor. El RFC advierte que un extremo hostil puede enviar una\ntrama enorme o una sucesión interminable de fragmentos pequeños. Las\nimplementaciones deben protegerse: fije un tamaño máximo de mensaje en la\nbiblioteca del servidor y cierre con el código 1009, message too big, cuando\nun extremo lo supere. La misma acumulación aparece en sentido contrario. En\nel navegador, `bufferedAmount` indica los bytes que `send()` ha puesto en\ncola y que aún esperan para salir a la red; el ejemplo de WHATWG envía la\nsiguiente actualización solo cuando ese número es cero. En el servidor, un\ncliente que lee despacio llena del mismo modo el búfer de salida. Cada\nconexión necesita un límite para ese búfer y una regla sobre qué hacer al\nalcanzarlo.\n\n## Lecturas adicionales\n\n- [RFC 6455: The WebSocket Protocol](https://www.rfc-editor.org/rfc/rfc6455) —\n  intercambio inicial, tramas, enmascaramiento y códigos de cierre, con las\n  razones de seguridad que hay detrás de cada uno.\n- [WebSockets Standard](https://websockets.spec.whatwg.org/) — API del\n  navegador: constructor, `send()`, `close()`, `bufferedAmount` y evento de\n  cierre.\n- [RFC 9110: HTTP Semantics](https://www.rfc-editor.org/rfc/rfc9110) — cabecera\n  `Upgrade` y estado 101 Switching Protocols en que se apoya el intercambio\n  inicial.\n- [Server-sent events](https://html.spec.whatwg.org/multipage/server-sent-events.html)\n  — alternativa unidireccional de HTML Standard, con reconexión incorporada.\n- [RFC 8441: Bootstrapping WebSockets with HTTP/2](https://www.rfc-editor.org/rfc/rfc8441)\n  — CONNECT extendido transporta WebSocket por un flujo HTTP/2 multiplexado.\n- [RFC 9220: Bootstrapping WebSockets with HTTP/3](https://www.rfc-editor.org/rfc/rfc9220)\n  — mecanismo correspondiente de CONNECT extendido para HTTP/3.\n\n\u003chttps://engineer.company/es/glossary/websocket/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Cómo una petición HTTP abre una conexión bidireccional que se mantiene abierta, cuándo supera a los sondeos y cinco formas en que puede fallar.","formats":{"gemtext":"https://engineer.company/es/glossary/websocket/index.gmi","gopher":"https://engineer.company/es/glossary/websocket/gophermap","html":"https://engineer.company/es/glossary/websocket/","json":"https://engineer.company/es/glossary/websocket/index.json","markdown":"https://engineer.company/es/glossary/websocket/index.md","pdf":"https://engineer.company/es/glossary/websocket/index.pdf"},"kind":"page","language":"es","title":"¿Qué es WebSocket?","url":"https://engineer.company/es/glossary/websocket/","version":1}