WebSocket explained

WebSocket is a computer communications protocol, providing a bidirectional communication channel over a single Transmission Control Protocol (TCP) connection. The protocol was standardized by the IETF as in 2011. The current specification allowing web applications to use this protocol is known as WebSockets.^[1] It is a living standard maintained by the WHATWG and a successor to The WebSocket API from the W3C.^[2]

WebSocket is distinct from HTTP used to serve most webpages. Although they are different, states that WebSocket "is designed to work over HTTP ports 443 and 80 as well as to support HTTP proxies and intermediaries", making the WebSocket protocol compatible with HTTP. To achieve compatibility, the WebSocket handshake uses the HTTP Upgrade header^[3] to change from the HTTP protocol to the WebSocket protocol.

The WebSocket protocol enables full-duplex interaction between a web browser (or other client application) and a web server with lower overhead than half-duplex alternatives such as HTTP polling, facilitating real-time data transfer from and to the server. This is achieved by providing a standardized way for the server to send content to the client without being first requested by the client, and allowing messages to be exchanged while keeping the connection open. In this way, a two-way ongoing conversation can take place between the client and the server. The communications are usually done over TCP port number 443 (or 80 in the case of unsecured connections), which is beneficial for environments that block non-web Internet connections using a firewall. Additionally, WebSocket enables streams of messages on top of TCP. TCP alone deals with streams of bytes with no inherent concept of a message. Similar two-way browser–server communications have been achieved in non-standardized ways using stopgap technologies such as Comet or Adobe Flash Player.^[4]

Most browsers support the protocol, including Google Chrome, Firefox, Microsoft Edge, Internet Explorer, Safari and Opera.^[5]

The WebSocket protocol specification defines ws (WebSocket) and wss (WebSocket Secure) as two new uniform resource identifier (URI) schemes^[6] that are used for unencrypted and encrypted connections respectively. Apart from the scheme name and fragment (i.e. # is not supported), the rest of the URI components are defined to use URI generic syntax.^[7]

History

WebSocket was first referenced as TCPConnection in the HTML5 specification, as a placeholder for a TCP-based socket API.^[8] In June 2008, a series of discussions were led by Michael Carter that resulted in the first version of the protocol known as WebSocket.^[9] Before WebSocket, port 80 full-duplex communication was attainable using Comet channels; however, Comet implementation is nontrivial, and due to the TCP handshake and HTTP header overhead, it is inefficient for small messages. The WebSocket protocol aims to solve these problems without compromising the security assumptions of the web.The name "WebSocket" was coined by Ian Hickson and Michael Carter shortly thereafter through collaboration on the #whatwg IRC chat room,^[10] and subsequently authored for inclusion in the HTML5 specification by Ian Hickson. In December 2009, Google Chrome 4 was the first browser to ship full support for the standard, with WebSocket enabled by default.^[11] Development of the WebSocket protocol was subsequently moved from the W3C and WHATWG group to the IETF in February 2010, and authored for two revisions under Ian Hickson.^[12]

After the protocol was shipped and enabled by default in multiple browsers, the was finalized under Ian Fette in December 2011.

introduced compression extension to WebSocket using the DEFLATE algorithm on a per-message basis.

Web API

A web application (e.g. web browser) may use the [[#WebSocket interface|WebSocket]] interface to maintain bidirectional communications with a WebSocket server.^[13]

Client example

In TypeScript.// Connect to serverconst ws = new WebSocket("wss://game.example.com/scoreboard");

// Receive ArrayBuffer instead of Blobws.binaryType = "arraybuffer";

// Set event listeners

ws.onopen = => ;

ws.onmessage = (event: MessageEvent) => ;

ws.onclose = (event: CloseEvent) => ;

ws.onerror = => ;

WebSocket interface

Type	Name[14]	Description
Constructor	ws = new '''WebSocket'''(url [, protocols ])	Start opening handshake.[15] '''[[url]]''': A string containing: Scheme: must be ws, wss, http or https. Host. Optional port: If not specified, 80 is used for ws and http, and 443 for wss and https. Optional path. Optional query. No fragment. Optional protocols: A string or an array of strings used as the value of the Sec-WebSocket-Protocol header in the opening handshake. Exceptions: SyntaxError: url parsing failed. url has an invalid scheme. url has a fragment. protocols has duplicate strings.
Method	ws.'''send'''(data)	Send data message.[16] data: must be string, Blob, ArrayBuffer or ArrayBufferView. Return: undefined. Exceptions: InvalidStateError: ws.readyState is CONNECTING. Note: If the data cannot be sent (e.g. because it would need to be buffered but the buffer is full), the connection is closed and the error event is fired.
	ws.'''close'''([ code ] [, reason ])	Start closing handshake.[17] Optional code: If specified, must be 1000 (Normal closure) or in the range 3000 to 4999 (application-defined). Defaults to 1000. Optional reason: If specified, must be a string whose UTF-8 encoding is up to 123 bytes. Defaults to an empty string. Return: undefined. Exceptions: InvalidAccessError: code is not 1000 nor is in the range 3000 to 4999. SyntaxError: UTF-8-encoded reason is longer than 123 bytes. Note: If ws.readyState is OPEN or CONNECTING, ws.readyState is set to CLOSING and the closing handshake starts. If ws.readyState is CLOSING or CLOSED, nothing happens (because the closing handshake has already started).
Event	ws.'''onopen''' = (event) => {}ws.addEventListener('''"open"''', (event) => {})	Opening handshake succeeded. event type is Event.
	ws.'''onmessage''' = (event) => {}{{nowrap|ws.addEventListener('''"message"''', (event) <nowiki>=></nowiki> {})}}|Data message received. event type is MessageEvent. This event is only fired if ws.readyState is OPEN.[18] event.data is the data received, of type: string for text. Blob or ArrayBuffer for binary (see ws.binaryType). event.origin is ws.url but only with the scheme, host, and port (if any). |-|ws.'''onclose''' = (event) => {}ws.addEventListener('''"close"''', (event) => {})|The underlying TCP connection closed. event type is CloseEvent.[19] [20] [21] [22] event.code: status code (integer). event.reason: reason for closing (string). event.wasClean: true if the TCP connection was closed after the closing handshake was completed, else false. Note: If the received Close frame contains a payload, event.code and event.reason get their value from the payload. If the received Close frame contains no payload, event.code is 1005 (No code received) and event.reason is an empty string. If no Close frame was received, event.code is 1006 (Connection closed abnormally) and event.reason is an empty string. |-|ws.'''onerror''' = (event) => {}ws.addEventListener('''"error"''', (event) => {})|Connection closed due to error. event type is Event.|-|Attribute|ws.'''binaryType''' (string)|Type of event.data in ws.onmessage when a binary data message is received. Initially set to "blob" (Blob object). May be changed to "arraybuffer" (ArrayBuffer object).[23] |-| rowspan="5" |Read-only attribute|ws.'''url''' (string)|URL given to the WebSocket constructor with the following transformations: If scheme is http or https, change it to ws or wss respectively. |-|ws.'''bufferedAmount''' (number)|Number of bytes of application data (UTF-8 text and binary data) that have been queued using ws.send but not yet transmitted to the network. It resets to zero once all queued data has been sent. If the connection closes, this value will only increase, with each call to ws.send, and never reset to zero.[24] |-|ws.'''protocol''' (string)|Protocol accepted by the server, or an empty string if protocols was not specified in the WebSocket constructor.|-|ws.'''extensions''' (string)|Extensions accepted by the server.|-|ws.'''readyState''' (number)|Connection state. It is one of the constants below. Initially set to CONNECTING.[25] |-| rowspan="4" |Constant|WebSocket.'''CONNECTING''' = 0|Opening handshake is currently in progress. The initial state of the connection.[26] [27] |-|WebSocket.'''OPEN''' = 1|Opening handshake succeeded. The client and server may send messages to each other.[28] [29] |-|WebSocket.'''CLOSING''' = 2|Closing handshake is currently in progress. Either ws.close was called or a Close message was received.[30] [31] |-|WebSocket.'''CLOSED''' = 3|The underlying TCP connection is closed.[32] |} Protocol Steps: Opening handshake: HTTP request and HTTP response. Frame-based message exchange: data, ping and pong messages. Closing handshake: close message (request then echoed in response). Opening handshake The client sends an HTTP request (method GET, version ≥ 1.1) and the server returns an HTTP response with status code 101 (Switching Protocols) on success. HTTP and WebSocket clients can connect to a server using the same port because the opening handshake uses HTTP. Sending additional HTTP headers (that are not in the table below) is allowed. HTTP headers may be sent in any order. After the Switching Protocols HTTP response, the opening handshake is complete, the HTTP protocol stops being used, and communication switches to a binary frame-based protocol.[33] [34] HTTP headers relevant to the opening handshake! !Header!Value!Mandatory Origin[35] Host[36] rowspan="6" Sec-WebSocket-Version[37] 13 Sec-WebSocket-Key[38] base64-encode(16 random bytes) Sec-WebSocket-Accept[39] base64-encode(SHA1(Sec-WebSocket-Key +)) Connection[40] [41] Upgrade Upgrade[42] [43] websocket Sec-WebSocket-Protocol[44] The request may contain a comma-separated list of strings (ordered by preference) indicating application-level protocols (built on top of WebSocket data messages) the client wishes to use. If the client sends this header, the server response must be one of the values from the list. rowspan="2" Sec-WebSocket-Extensions[45] [46] [47] [48] Used to negotiate protocol-level extensions. The client may request extensions to the WebSocket protocol by including a comma-separated list of extensions (ordered by preference). Each extension may have a parameter (e.g. foo=4). The server may accept some or all extensions requested by the client. This field may appear multiple times in the request (logically equivalent to a single occurrence containing all values) and must not appear more than once in the response. Example request: GET /chat HTTP/1.1Host: server.example.comUpgrade: websocketConnection: UpgradeSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ Origin: http://example.comSec-WebSocket-Protocol: chat, superchatSec-WebSocket-Version: 13 Example response: HTTP/1.1 101 Switching ProtocolsUpgrade: websocketConnection: UpgradeSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=Sec-WebSocket-Protocol: chat The following Python code generates a random Sec-WebSocket-Key.import base64import os print(base64.b64encode(os.urandom(16))) The following Python code calculates Sec-WebSocket-Accept using Sec-WebSocket-Key from the example request above.import base64import hashlib KEY: bytes = b"dGhlIHNhbXBsZSBub25jZQ "MAGIC: bytes = b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11"print(base64.b64encode(hashlib.sha1(KEY + MAGIC).digest)) Sec-WebSocket-Key and Sec-WebSocket-Accept are intended to prevent a caching proxy from re-sending a previous WebSocket conversation,[49] and does not provide any authentication, privacy, or integrity. Though some servers accept a short Sec-WebSocket-Key, many modern servers will reject the request with error "invalid Sec-WebSocket-Key header". Frame-based message After the opening handshake, the client and server can, at any time, send data messages (text or binary) and control messages (Close, Ping, Pong) to each other. A message is composed of one frame if unfragmented or at least two frames if fragmented. Fragmentation splits a message into two or more frames. It enables sending messages with initial data available but complete length unknown. Without fragmentation, the whole message must be sent in one frame, so the complete length is needed before the first byte can be sent, which requires a buffer.[50] It was proposed to extend this feature to enable multiplexing several streams simultaneously (e.g. to avoid monopolizing a socket for a single large payload), but the protocol extension was never accepted.[51] An unfragmented message consists of one frame with FIN = 1 and opcode ≠ 0. A fragmented message consists of one frame with FIN = 0 and opcode ≠ 0, followed by zero or more frames with FIN = 0 and opcode = 0, and terminated by one frame with FIN = 1 and opcode = 0. Frame structure Offset (bits) Field[52] Size (bits) Description 0 FIN[53] 1 1 RSV1 1 rowspan="3" 2 RSV2 1 3 RSV3 1 4 Opcode 4 See opcodes below. 8 Masked[54] 1 See client-to-server masking below. 9 Payload length[55] 7, 7+16 or 7+64 Length of the payload (extension data + application data) in bytes. Endianness is big-endian. Signedness is unsigned. The minimum number of bits must be used to encode the length. Masking key[56] 0 or 32 Random nonce. Present if the masked field is 1. The client generates a masking key for every masked frame. Payload Extension data Payload length (bytes) Application data on the opcode Opcodes Frame type[57] Opcode[58] RelatedWeb API Description Purpose Max. payload length (bytes) Continuation frame 0 Non-first frame of a fragmented message. Message fragmentation Non-control frame Text 1 send, UTF-8-encoded text. Data message rowspan="3" Binary 2 Binary data. 3–7 Control frame[59] Close 8 close, onclose The WebSocket closing handshake starts upon either sending or receiving a Close frame.[60] It may prevent data loss by complementing the TCP closing handshake.[61] No frame can be sent after sending a Close frame. If a Close frame is received and no prior Close frame was sent, a Close frame must be sent in response (typically echoing the status code received). The payload is optional, but if present, it must start with a two-byte big-endian unsigned integer status code, optionally followed by a UTF-8-encoded reason message not longer than 123 bytes.[62] Protocol state 125 Ping 9 , keepalive and heartbeat. Both sides can send a ping (with any payload). Whoever receives it must, as soon as is practical, send back a pong with the same payload. A pong should be ignored if no prior ping was sent.[63] [64] [65] Pong 10 11–15 Client-to-server masking A client must mask all frames sent to the server. A server must not mask any frames sent to the client.[66] Frame masking applies XOR between the payload and the masking key. The following pseudocode describes the algorithm used to both mask and unmask a frame. for i from 0 to payload_length − 1 payload[i] := payload[i] xor masking_key[i mod 4] Status codes Range[67] Allowed in Close frame Code[68] Description 0–999 1000–2999 (Protocol) 1000 Normal closure. 1001 Going away (e.g. browser tab closed; server going down). 1002 Protocol error. 1003 Unsupported data (e.g. endpoint only understands text but received binary). 1004 1005 No code received. 1006 Connection closed abnormally (i.e. closing handshake did not occur). 1007 Invalid payload data (e.g. non UTF-8 data in a text message). 1008 Policy violated. 1009 Message too big. 1010 Unsupported extension. The client should write the extensions it expected the server to support in the payload. 1011 Internal server error. 1015 TLS handshake failure. 3000–3999 Reserved for libraries, frameworks and applications. Registered directly with IANA. 4000–4999 Private use. Compression extension The permessage-deflate extension allows data messages to be compressed using the DEFLATE algorithm.For example, during the opening handshake, the client and server may use the following header to enable the extension. The RSV1 field of the first frame of a data message must be set to indicate the payload data is compressed.[69] Sec-WebSocket-Extensions: permessage-deflate Server implementation example In Python. Note: recv returns up to the amount of bytes requested. For readability, the code ignores that, thus it may fail in non-ideal network conditions.import base64import hashlibimport structfrom typing import Optionalfrom socket import socket as Socket def handle_websocket_connection(ws: Socket) -> None: # Accept connection conn, addr = ws.accept # Receive and parse HTTP request key: Optional[bytes] = None for line in conn.recv(4096).split(b"\r\n"): if line.startswith(b"Sec-WebSocket-Key"): key = line.split[-1] if key is None: raise ValueError("Sec-WebSocket-Key not found") # Send HTTP response sec_accept = base64.b64encode(hashlib.sha1(key + b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11").digest) conn.sendall(b"\r\n".join([b"HTTP/1.1 101 Switching Protocols", b"Connection: Upgrade", b"Upgrade: websocket", b"Sec-WebSocket-Accept: " + sec_accept, b"", b"", ])) # Decode and print frames while True: byte0, byte1 = conn.recv(2) fin: int = byte0 >> 7 opcode: int = byte0 & 0b1111 masked: int = byte1 >> 7 assert masked, "The client must mask all frames" if opcode >= 8: assert fin, "Control frames are unfragmentable" # Payload size payload_size: int = byte1 & 0b111_1111 if payload_size 126: payload_size, = struct.unpack(">H", conn.recv(2)) assert payload_size > 125, "The minimum number of bits must be used" elif payload_size 127: payload_size, = struct.unpack(">Q", conn.recv(8)) assert payload_size > 2**16-1, "The minimum number of bits must be used" assert payload_size <= 2**63-1, "The most significant bit must be zero" if opcode >= 8: assert payload_size <= 125, "Control frames must have up to 125 bytes" # Unmask masking_key: bytes = conn.recv(4) payload: bytearray = bytearray(conn.recv(payload_size)) for i in range(payload_size): payload[i] = payload[i] ^ masking_key[i % 4] print("Received frame", FIN, opcode, payload) if __name__ Browser support A secure version of the WebSocket protocol is implemented in Firefox 6,[70] Safari 6, Google Chrome 14,[71] Opera 12.10 and Internet Explorer 10.[72] A detailed protocol test suite report[73] lists the conformance of those browsers to specific protocol aspects. An older, less secure version of the protocol was implemented in Opera 11 and Safari 5, as well as the mobile version of Safari in iOS 4.2.[74] The BlackBerry Browser in OS7 implements WebSockets.[75] Because of vulnerabilities, it was disabled in Firefox 4 and 5,[76] and Opera 11.[77] Using browser developer tools, developers can inspect the WebSocket handshake as well as the WebSocket frames.[78] Protocol version Draft date Internet Explorer Firefox[79] (PC) Firefox (Android) Chrome (PC, Mobile) Safari (Mac, iOS) Opera (PC, Mobile) Android Browser hixie-75 February 4, 2010 4 5.0.0 hixie-76 hybi-00 May 6, 2010 May 23, 2010 4.0 (disabled) 6 5.0.1 11.00 (disabled) hybi-07, v7 April 22, 2011 6[80] hybi-10, v8 July 11, 2011 7[81] 7 14[82] , v13 December, 2011 10[83] 11 11 16[84] 6 12.10[85] 4.4 Server implementations Nginx has supported WebSockets since 2013, implemented in version 1.3.13[86] including acting as a reverse proxy and load balancer of WebSocket applications.[87] Apache HTTP Server has supported WebSockets since July, 2013, implemented in version 2.4.5[88] [89] Internet Information Services added support for WebSockets in version 8 which was released with Windows Server 2012.[90] lighttpd has supported WebSockets since 2017, implemented in lighttpd 1.4.46.[91] lighttpd mod_proxy can act as a reverse proxy and load balancer of WebSocket applications. lighttpd mod_wstunnel can act as a WebSocket endpoint to transmit arbitrary data, including in JSON format, to a backend application. lighttpd supports WebSockets over HTTP/2 since 2022, implemented in lighttpd 1.4.65.[92] Eclipse Mosquitto This is an MQTT broker, but it supports the MQTT over WebSocket. So, it can be considered a type of WebSocket implementation. ASP.NET Core have support for WebSockets using the middleware.[93] Security considerations Unlike regular cross-domain HTTP requests, WebSocket requests are not restricted by the same-origin policy. Therefore, WebSocket servers must validate the "Origin" header against the expected origins during connection establishment, to avoid cross-site WebSocket hijacking attacks (similar to cross-site request forgery), which might be possible when the connection is authenticated with cookies or HTTP authentication. It is better to use tokens or similar protection mechanisms to authenticate the WebSocket connection when sensitive (private) data is being transferred over the WebSocket.[94] A live example of vulnerability was seen in 2020 in the form of Cable Haunt. Proxy traversal WebSocket protocol client implementations try to detect whether the user agent is configured to use a proxy when connecting to destination host and port, and if it is, uses HTTP CONNECT method to set up a persistent tunnel. The WebSocket protocol is unaware of proxy servers and firewalls. Some proxy servers are transparent and work fine with WebSocket; others will prevent WebSocket from working correctly, causing the connection to fail. In some cases, additional proxy-server configuration may be required, and certain proxy servers may need to be upgraded to support WebSocket. If unencrypted WebSocket traffic flows through an explicit or a transparent proxy server without WebSockets support, the connection will likely fail.[95] If an encrypted WebSocket connection is used, then the use of Transport Layer Security (TLS) in the WebSocket Secure connection ensures that an HTTP CONNECT command is issued when the browser is configured to use an explicit proxy server. This sets up a tunnel, which provides low-level end-to-end TCP communication through the HTTP proxy, between the WebSocket Secure client and the WebSocket server. In the case of transparent proxy servers, the browser is unaware of the proxy server, so no HTTP CONNECT is sent. However, since the wire traffic is encrypted, intermediate transparent proxy servers may simply allow the encrypted traffic through, so there is a much better chance that the WebSocket connection will succeed if WebSocket Secure is used. Using encryption is not free of resource cost, but often provides the highest success rate, since it would be travelling through a secure tunnel. A mid-2010 draft (version hixie-76) broke compatibility with reverse proxies and gateways by including eight bytes of key data after the headers, but not advertising that data in a Content-Length: 8 header.[96] This data was not forwarded by all intermediates, which could lead to protocol failure. More recent drafts (e.g., hybi-09[97]) put the key data in a Sec-WebSocket-Key header, solving this problem. See also Comparison of WebSocket implementations Network socket Push technology XMLHttpRequest Server-sent events WebRTC HTTP/2 Internet protocol suite BOSH External links IETF Hypertext-Bidirectional (HyBi) working group The WebSocket protocol – Proposed Standard published by the IETF HyBi Working Group The WebSocket protocol – Internet-Draft published by the IETF HyBi Working Group The WebSocket protocol – Original protocol proposal by Ian Hickson The WebSocket API – W3C Working Draft specification of the API The WebSocket API – W3C Candidate Recommendation specification of the API WebSocket.org WebSocket demos, loopback tests, general information and community

Notes and References

1. Web site: WebSockets Standard . 2022-05-16 . WHATWG WebSockets. 2023-03-12 . https://web.archive.org/web/20230312232711/https://websockets.spec.whatwg.org/ . live .
2. Web site: The WebSocket API . 2022-05-16 . www.w3.org . en . 2022-06-08 . https://web.archive.org/web/20220608221509/https://www.w3.org/TR/2021/NOTE-websockets-20210128/Overview.html . live .
3. RFC 6455 The WebSocket Protocol . . 1.7 . Relationship to TCP and HTTP . 6455 . December 2011. Ian Fette . Alexey Melnikov.
4. Web site: Adobe Flash Platform – Sockets . 2021-07-28 . help.adobe.com . TCP connections require a "client" and a "server". Flash Player can create client sockets. . 2021-04-18 . https://web.archive.org/web/20210418211002/https://help.adobe.com/en_US/as3/dev/WSb2ba3b1aad8a27b0-181c51321220efd9d1c-8000.html . live .
5. Web site: 2023-04-06 . The WebSocket API (WebSockets) . live . https://web.archive.org/web/20210728161324/https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API . 2021-07-28 . 2021-07-26 . MDN Web Docs . Mozilla Developer Network . en-US.
6. Web site: IANA Uniform Resource Identifier (URI) Schemes . . 2011-11-14 . 2011-12-10 . Graham Klyne . 2013-04-25 . https://web.archive.org/web/20130425164755/http://www.iana.org/assignments/uri-schemes.html . live .
7. RFC 6455 The WebSocket Protocol . . 3 . WebSocket URIs . 6455 . December 2011 . Ian Fette . Alexey Melnikov.
8. Web site: HTML 5. www.w3.org. 2016-04-17. 2016-09-16. https://web.archive.org/web/20160916071246/http://www.w3.org/TR/2008/WD-html5-20080610/comms.html#tcp-connections. live.
9. Web site: [whatwg] TCPConnection feedback from Michael Carter on 2008-06-18 (whatwg.org from June 2008)]. lists.w3.org. 2016-04-17. 2016-04-27. https://web.archive.org/web/20160427004936/https://lists.w3.org/Archives/Public/public-whatwg-archive/2008Jun/0165.html. live.
10. Web site: IRC logs: freenode / #whatwg / 20080618. krijnhoetmer.nl. 2016-04-18. 2016-08-21. https://web.archive.org/web/20160821040755/http://krijnhoetmer.nl/irc-logs/whatwg/20080618#l-1145. live.
11. Web site: Web Sockets Now Available In Google Chrome. Chromium Blog. en-US. 2016-04-17. 2021-12-09. https://web.archive.org/web/20211209195505/https://blog.chromium.org/2009/12/web-sockets-now-available-in-google.html. live.
12. The WebSocket protocol. . Ian Hickson. Ietf Datatracker. 6 May 2010. 2016-04-17. 2017-03-17. https://web.archive.org/web/20170317201023/https://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75. live.
13. Web site: Introduction. WHATWG WebSockets. sec. 1..
14. Web site: Interface definition . WHATWG WebSockets. sec. 3.1.. 2024-04-10 . 2023-03-12 . https://web.archive.org/web/20230312232711/https://websockets.spec.whatwg.org/#interface-definition . live .
15. Web site: new WebSocket(url, protocols) . WHATWG WebSockets. sec. 3.1.. 2024-04-30 . 2023-03-12 . https://web.archive.org/web/20230312232711/https://websockets.spec.whatwg.org/#dom-websocket-websocket . live .
16. Web site: send(data) . WHATWG WebSockets . sec. 3.1..
17. Web site: close(code, reason) . WHATWG WebSockets. sec. 3.1.. 2024-04-10 . 2023-03-12 . https://web.archive.org/web/20230312232711/https://websockets.spec.whatwg.org/#dom-websocket-close . live .
18. Web site: When a WebSocket message has been received. WHATWG WebSockets. sec. 4..
19. Web site: When the WebSocket connection is closed; substep 3. . WHATWG WebSockets. sec. 4.. 2024-04-13 . 2023-03-12 . https://web.archive.org/web/20230312232711/https://websockets.spec.whatwg.org/#closeWebSocket . live .
20. 6455. The WebSocket Connection is Closed. 7.1.4.
21. 6455. The WebSocket Connection Close Code. 7.1.5.
22. 6455. The WebSocket Connection Close Reason. 7.1.6.
23. Web site: socket.binaryType. WHATWG WebSockets. sec. 3.1..
24. Web site: socket.bufferedAmount. WHATWG WebSockets. sec. 3.1..
25. Web site: ready state. WHATWG WebSockets. sec. 3.1..
26. Web site: CONNECTING . WHATWG WebSockets. sec. 3.1.. 2024-04-13 . 2023-03-12 . https://web.archive.org/web/20230312232711/https://websockets.spec.whatwg.org/#ref-for-dom-websocket-connecting%E2%91%A0 . live .
27. 6455. Client Requirements. 4.1. 14.
28. Web site: OPEN . WHATWG WebSockets. sec. 3.1.. 2024-04-10 . 2023-03-12 . https://web.archive.org/web/20230312232711/https://websockets.spec.whatwg.org/#dom-websocket-open . live .
29. 6455. _The WebSocket Connection is Established_. 20.
30. Web site: CLOSING . WHATWG WebSockets. sec. 3.1.. 2024-04-10 . 2023-03-12 . https://web.archive.org/web/20230312232711/https://websockets.spec.whatwg.org/#dom-websocket-closing . live .
31. 6455. The WebSocket Closing Handshake is Started. 7.1.3.
32. Web site: CLOSED. WHATWG WebSockets. sec. 3.1.. 2024-04-10. 2023-03-12. https://web.archive.org/web/20230312232711/https://websockets.spec.whatwg.org/#dom-websocket-closed. live.
33. Opening Handshake. 6455. 1.3.
34. Protocol Overview. 1.2. 6455.
35. 6455. 18. Client requirement 8...
36. 6455. 17. Client requirement 4...
37. 6455. Client requirement 9... 18.
38. 6455. 18. Client requirement 7...
39. 6455. Server step 5.4... 24.
40. 6455. Client requirement 6... 18.
41. 6455. Server step 5.3.. 24.
42. 6455. Client requirement 5... 17.
43. 6455. Server step 5.2.. 24.
44. 6455. Client requirement 10... 18.
45. 6455. Client requirement 11... 19.
46. 6455. Sec-WebSocket-Extensions. 11.3.2.
47. 6455. Extensions. 9.
48. 6455. Negotiating Extensions. 9.1.
49. Web site: Main Goal of WebSocket protocol . 25 July 2015 . IETF . The computation [...] is meant to prevent a caching intermediary from providing a WS-client with a cached WS-server reply without actual interaction with the WS-server. . 22 April 2016 . https://web.archive.org/web/20160422042232/https://trac.tools.ietf.org/wg/hybi/trac/wiki/FAQ . live .
50. 5.4. 6455. Fragmentation.
51. draft-ietf-hybi-websocket-multiplexing. A Multiplexing Extension for WebSockets. John A. Tamplin. Takeshi Yoshino. IETF. 2013.
52. 6455. Base Framing Protocol. 5.2.
53. 6455. FIN. 28.
54. 6455. Mask. 29.
55. 6455. Payload length. 29.
56. Client-to-Server Masking. 5.3. 6455.
57. 6455. frame-opcode. 31.
58. 6455. Opcode. 29.
59. Control Frames. 5.5. 6455.
60. The WebSocket Closing Handshake is Started. 7.1.3. 6455.
61. Closing Handshake. 1.4. 6455.
62. Close. 5.5.1. 6455.
63. Ping. 5.5.2. 6455.
64. Pong. 5.5.3. 6455.
65. Web site: Ping and Pong frames. WHATWG WebSockets.
66. Overview. 5.1. 6455.
67. 7.4.2. 6455. Reserved Status Code Ranges.
68. 7.4.1. 6455. Defined Status Codes.
69. 7692. Compression Extensions for WebSocket.
70. Web site: WebSocket enabled in Firefox 6 . Dirkjan Ochtman . May 27, 2011 . Mozilla.org . 2011-06-30 . 2012-05-26 . https://web.archive.org/web/20120526230019/https://developer.mozilla.org/en/WebSockets . dead .
71. Web site: Chromium Web Platform Status . 2011-08-03 . 2017-03-04 . https://web.archive.org/web/20170304203008/http://www.chromium.org/developers/web-platform-status . live .
72. Web site: WebSockets (Windows) . Microsoft . 2012-09-28 . 2012-11-07 . 2015-03-25 . https://web.archive.org/web/20150325091443/https://msdn.microsoft.com/en-us/library/ie/hh673567(v=vs.85).aspx . live .
73. Web site: WebSockets Protocol Test Report . Tavendo.de . 2011-10-27 . 2011-12-10 . 2016-09-22 . https://web.archive.org/web/20160922040928/http://autobahn.ws/testsuite/reports/clients/index.html . dead .
74. Web site: Apple adds accelerometer, WebSockets support to Safari in iOS 4.2 . Katie Marsal . November 23, 2010 . AppleInsider.com . 2011-05-09 . 2011-03-01 . https://web.archive.org/web/20110301114256/http://www.appleinsider.com/articles/10/11/23/apple_adds_accelerometer_websockets_support_to_safari_in_ios_4_2.html . live .
75. Web site: Web Sockets API . . 8 July 2011 . dead . https://web.archive.org/web/20110610191150/http://docs.blackberry.com/en/developers/deliverables/29271/Web_Sockets_support_1582781_11.jsp . June 10, 2011 .
76. Web site: WebSocket disabled in Firefox 4 . Chris Heilmann . December 8, 2010 . Hacks.Mozilla.org . 2011-05-09 . 2017-03-06 . https://web.archive.org/web/20170306114251/https://hacks.mozilla.org/2010/12/websockets-disabled-in-firefox-4/ . live .
77. Web site: Regarding WebSocket . Aleksander Aas . December 10, 2010 . My Opera Blog . 2011-05-09 . https://web.archive.org/web/20101215010748/http://my.opera.com/chooseopera/blog/2010/12/10/regarding-websocket. 2010-12-15.
78. Book: Wang . Vanessa . Salim . Frank . Moskovits . Peter . The Definitive Guide to HTML5 WebSocket . http://my.safaribooksonline.com/book/-/9781430247401/appendix-a-inspecting-websocket-traffic/sec1_xhtml . 7 April 2013 . February 2013 . Apress . 978-1-4302-4740-1 . APPENDIX A: WebSocket Frame Inspection with Google Chrome Developer Tools . 31 December 2015 . https://web.archive.org/web/20151231184436/http://my.safaribooksonline.com/book/-/9781430247401/appendix-a-inspecting-websocket-traffic/sec1_xhtml . dead .
79. Web site: WebSockets (support in Firefox) . Mozilla Foundation . developer.mozilla.org . 2011-09-30 . 2011-12-10 . 2012-05-26 . https://web.archive.org/web/20120526230019/https://developer.mozilla.org/en/WebSockets . dead .
80. Web site: Bug 640003 - WebSockets - upgrade to ietf-06 . Mozilla Foundation . 2011-03-08 . 2011-12-10 . 2021-04-01 . https://web.archive.org/web/20210401044535/https://bugzilla.mozilla.org/show_bug.cgi?id=640003 . live .
81. Web site: Bug 640003 - WebSockets - upgrade to ietf-07(comment 91). Mozilla Foundation. 2011-07-22. 2011-07-28. 2021-04-01. https://web.archive.org/web/20210401044535/https://bugzilla.mozilla.org/show_bug.cgi?id=640003#c91. live.
82. Web site: Chromium bug 64470 . code.google.com . 2010-11-25 . 2011-12-10 . 2015-12-31 . https://web.archive.org/web/20151231184436/https://code.google.com/p/chromium/issues/detail?id=64470 . live .
83. Web site: WebSockets in Windows Consumer Preview . Microsoft . IE Engineering Team . 2012-03-19 . 2012-07-23 . 2015-09-06 . https://web.archive.org/web/20150906135037/http://blogs.msdn.com/b/ie/archive/2012/03/19/websockets-in-windows-consumer-preview.aspx . live .
84. Web site: WebKit Changeset 97247: WebSocket: Update WebSocket protocol to hybi-17 . trac.webkit.org . 2011-12-10 . 2012-01-05 . https://web.archive.org/web/20120105121750/http://trac.webkit.org/changeset/97249 . live .
85. Web site: A hot Opera 12.50 summer-time snapshot . Opera Developer News . 2012-08-03 . 2012-08-03. https://web.archive.org/web/20120805234006/http://my.opera.com/ODIN/blog/2012/08/03/a-hot-opera-12-50-summer-time-snapshot. 2012-08-05.
86. Web site: Welcome to nginx! . nginx.org . 3 February 2022 . https://web.archive.org/web/20120717224952/http://nginx.org/en/CHANGES. 17 July 2012. dead.
87. Web site: Using NGINX as a WebSocket Proxy. May 17, 2014. NGINX. November 3, 2019. October 6, 2019. https://web.archive.org/web/20191006062348/https://www.nginx.com/blog/websocket-nginx/. live.
88. Web site: Overview of new features in Apache HTTP Server 2.4. Apache. 2021-01-26. 2020-11-11. https://web.archive.org/web/20201111201741/http://httpd.apache.org/docs/trunk/new_features_2_4.html. live.
89. Web site: Changelog Apache 2.4. Apache Lounge. 2021-01-26. 2021-01-22. https://web.archive.org/web/20210122162741/https://www.apachelounge.com/Changelog-2.4.html. live.
90. Web site: IIS 8.0 WebSocket Protocol Support . 28 November 2012 . Microsoft Docs . 2020-02-18 . 2020-02-18 . https://web.archive.org/web/20200218153735/https://docs.microsoft.com/en-us/iis/get-started/whats-new-in-iis-8/iis-80-websocket-protocol-support . live .
91. Web site: Release-1 4 46 - Lighttpd - lighty labs . 2020-12-29 . 2021-01-16 . https://web.archive.org/web/20210116155634/https://redmine.lighttpd.net/projects/lighttpd/wiki/Release-1_4_46 . live .
92. Web site: Release-1 4 65 - Lighttpd - lighty labs . 2024-05-03 . 2024-05-03 . https://web.archive.org/web/20240503061036/https://redmine.lighttpd.net/projects/lighttpd/wiki/Release-1_4_65 . live .
93. Web site: WebSockets support in ASP.NET Core . learn.microsoft.com . 2 May 2025 . en-us.
94. Web site: Cross-Site WebSocket Hijacking (CSWSH) . Christian Schneider . Web Application Security Blog . August 31, 2013 . December 30, 2015 . December 31, 2016 . https://web.archive.org/web/20161231061757/http://www.christian-schneider.net/CrossSiteWebSocketHijacking.html#main . live .
95. Web site: How HTML5 Web Sockets Interact With Proxy Servers . Infoq.com . March 16, 2010 . C4Media Inc. . Peter Lubbers . 2011-12-10 . 2016-05-08 . https://web.archive.org/web/20160508202722/http://www.infoq.com/articles/Web-Sockets-Proxy-Servers . live .
96. Web site: WebSocket -76 is incompatible with HTTP reverse proxies . ietf.org . Internet Engineering Task Force . 2010-07-06 . 2011-12-10 . Willy Tarreau . email . 2016-09-17 . https://web.archive.org/web/20160917063052/http://www.ietf.org/mail-archive/web/hybi/current/msg02149.html . live .
97. The WebSocket protocol, draft hybi-09 . Sec-WebSocket-Key . 11.4 . June 13, 2011 . June 15, 2011 . Ian Fette .