{{APIRef("Websockets API")}}

The**`code`** read-only property of the {{domxref("CloseEvent")}} interface returns a[WebSocket connection close code](https://www.rfc-editor.org/rfc/rfc6455.html#section-7.1.5) indicating the reason theserver gave for closing the connection.

The**`code`** read-only property of the {{domxref("CloseEvent")}} interface returns a[WebSocket connection close code](https://www.rfc-editor.org/rfc/rfc6455.html#section-7.1.5) indicating the reason theconnection was closed.

An integer[WebSocket connection close code](https://www.rfc-editor.org/rfc/rfc6455.html#section-7.1.5) in the range`1000` -`4999`, indicating the reason theserver gave for closing the connection.

An integer[WebSocket connection close code](https://www.rfc-editor.org/rfc/rfc6455.html#section-7.1.5) in the range`1000` -`4999`, indicating the reason theconnection was closed.

<tableclass="no-markdown">

<thead>

_This interface also inherits properties from its parent, {{domxref("Event")}}._

- {{domxref("CloseEvent.code")}} {{ReadOnlyInline}}

- : Returns an`unsigned short` containing the close code sent by the server.

- : Returns an`unsigned short` containing the close code.

- {{domxref("CloseEvent.reason")}} {{ReadOnlyInline}}

- : Returns a string indicating the reason the server closed the connection. This is specific to the particular server and sub-protocol.

- {{domxref("CloseEvent.wasClean")}} {{ReadOnlyInline}}

To construct a`WebSocket`, use the[`WebSocket()`](/en-US/docs/Web/API/WebSocket/WebSocket) constructor.

{{InheritanceDiagram}}

title:The WebSocket API (WebSockets)

slug:Web/API/WebSockets_API

page-type:web-api-overview

browser-compat:api.WebSocket

browser-compat:

-api.WebSocket

-api.WebSocketStream

{{DefaultAPISidebar("WebSockets API")}}

The**WebSocket API** is an advanced technology that makes it possible to open a two-way interactive communication session between the user's browser and a server. With this API, you can send messages to a server and receive event-driven responses without having to poll the server for a reply.

The**WebSocket API** makes it possible to open a two-way interactive communication session between the user's browser and a server. With this API, you can send messages to a server and receive responses without having to poll the server for a reply.

The WebSocket API provides two alternative mechanisms for creating and using web socket connections: the {{domxref("WebSocket")}} interface and the {{domxref("WebSocketStream")}} interface.

- The`WebSocket` interface is stable and has good browser and server support. However it doesn't support[backpressure](/en-US/docs/Web/API/Streams_API/Concepts#backpressure). As a result, when messages arrive faster than the application can process them it will either fill up the device's memory by buffering those messages, become unresponsive due to 100% CPU usage, or both.

- The`WebSocketStream` is a {{jsxref("Promise")}}-based alternative to`WebSocket`. It uses the[Streams API](/en-US/docs/Web/API/Streams_API) to handle receiving and sending messages, meaning that socket connections can take advantage of stream backpressure automatically, regulating the speed of reading or writing to avoid bottlenecks in the application. However,`WebSocketSteam` is non-standard and currently only supported in one rendering engine.

Additionally, the[WebTransport API](/en-US/docs/Web/API/WebTransport_API) is expected to replace the WebSocket API for many applications. WebTransport is a versatile, low-level API that provides backpressure and many other features not supported by either`WebSocket` or`WebSocketStream`, such as unidirectional streams, out-of-order delivery, and unreliable data transmission via datagrams. WebTransport is more complex to use than WebSockets and its cross-browser support is not as wide, but it enables the implementation of sophisticated solutions. If standard WebSocket connections are a good fit for your use case and you need wide browser compatibility, you should employ the WebSockets API to get up and running quickly. However, if your application requires a non-standard custom solution, then you should use the WebTransport API.

- : The primary interface for connecting to a WebSocket server and then sending and receiving data on the connection.

-[`WebSocketStream`](/en-US/docs/Web/API/WebSocketStream) {{non-standard_inline}}

- : Promise-based interface for connecting to a WebSocket server; uses[streams](/en-US/docs/Web/API/Streams_API) to send and receive data on the connection.

- : The event sent by the WebSocket object when the connection closes.

-[Writing a WebSocket server in C#](/en-US/docs/Web/API/WebSockets_API/Writing_WebSocket_server)

-[Writing a WebSocket server in Java](/en-US/docs/Web/API/WebSockets_API/Writing_a_WebSocket_server_in_Java)

-[Writing a WebSocket server in JavaScript (Deno)](/en-US/docs/Web/API/WebSockets_API/Writing_a_WebSocket_server_in_JavaScript_Deno)

-[Using WebSocketStream to write a client](/en-US/docs/Web/API/WebSockets_API/Using_WebSocketStream)

-[AsyncAPI](https://www.asyncapi.com/): A specification for describing event-driven architectures based on protocols like WebSocket. You can use it to describe WebSocket-based APIs just as you would describe REST APIs with the OpenAPI specification. Learn[why you should consider using AsyncAPI with WebSocket](https://www.asyncapi.com/blog/websocket-part1) and[how to do so](https://www.asyncapi.com/blog/websocket-part2).

-[HumbleNet](https://hacks.mozilla.org/2017/06/introducing-humblenet-a-cross-platform-networking-library-that-works-in-the-browser/): A cross-platform networking library that works in the browser. It consists of a C wrapper around WebSockets and WebRTC that abstracts away cross-browser differences, facilitating the creation of multi-user networking functionality for games and other apps.

-[µWebSockets](https://github.com/uNetworking/uWebSockets): Highly scalable WebSocket server and client implementation for[C++11](https://isocpp.org/) and[Node.js](https://nodejs.org/).

-[Socket.IO](https://socket.io/): A long polling/WebSocket based third party transfer protocol for[Node.js](https://nodejs.org/).

-[SocketCluster](https://socketcluster.io/): A pub/sub WebSocket framework for[Node.js](https://nodejs.org/) with a focus on scalability.

-[WebSocket-Node](https://github.com/theturtle32/WebSocket-Node): A WebSocket server API implementation for[Node.js](https://nodejs.org/).

-[Total.js](https://www.totaljs.com/): Web application framework for[Node.js](https://nodejs.org/en) (Example:[WebSocket chat](https://github.com/totaljs/examples/tree/master/websocket))

-[Faye](https://www.npmjs.com/package/faye-websocket): A {{DOMxRef("WebSocket")}} (two-ways connections) and[EventSource](/en-US/docs/Web/API/EventSource) (one-way connections) for[Node.js](https://nodejs.org/) Server and Client.

-[SignalR](https://dotnet.microsoft.com/en-us/apps/aspnet/signalr): SignalR will use WebSockets under the covers when it's available, and gracefully fallback to other techniques and technologies when it isn't, while your application code stays the same.

-[Caddy](https://caddyserver.com/): A web server capable of proxying arbitrary commands (stdin/stdout) as a websocket.

-[ws](https://github.com/websockets/ws): a popular WebSocket client & server library for[Node.js](https://nodejs.org/en).

-[jsonrpc-bidirectional](https://github.com/bigstepinc/jsonrpc-bidirectional): Asynchronous RPC which, on a single connection, may have functions exported on the server and, and the same time, on the client (client may call server, server may also call client).

-[cowboy](https://github.com/ninenines/cowboy): Cowboy is a small, fast and modern HTTP server for Erlang/OTP with WebSocket support.

-[ZeroMQ](https://zeromq.org/): ZeroMQ is embeddable networking library that carries messages across in-process, IPC, TCP, UDP, TIPC, multicast and WebSocket.

-[WebSocket King](https://websocketking.com/): A client tool to help develop, test and work with WebSocket servers.

-[PHP WebSocket Server](https://github.com/napengam/phpWebSocketServer): Server written in PHP to handle connections via websockets`wss://` or`ws://` and normal sockets over`ssl://`,`tcp://`

-[Channels](https://channels.readthedocs.io/en/stable/index.html): Django library that adds support for WebSockets (and other protocols that require long running asynchronous connections).

-[Channels](https://hexdocs.pm/phoenix/channels.html): Scalable real-time communication using WebSocket in Elixir Phoenix framework.

-[LiveView](https://github.com/phoenixframework/phoenix_live_view): Real-time interactive web experiences through WebSocket in Elixir Phoenix framework.

-[DjangoChannels](https://channels.readthedocs.io/en/stable/index.html): Django library that adds support for WebSockets (and other protocols that require long running asynchronous connections).

-[(Phoenix)Channels](https://hexdocs.pm/phoenix/channels.html): Scalable real-time communication using WebSocket in Elixir Phoenix framework.

-[PhoenixLiveView](https://github.com/phoenixframework/phoenix_live_view): Real-time interactive web experiences through WebSocket in Elixir Phoenix framework.

-[Flask-SocketIO](https://flask-socketio.readthedocs.io/en/latest/): gives Flask applications access to low latency bi-directional communications between the clients and the server.

-[Gorilla WebSocket](https://pkg.go.dev/github.com/gorilla/websocket): Gorilla WebSocket is a[Go](https://go.dev/) implementation of the WebSocket protocol.