This article explores the differences between two popular realtime web communication technologies: gRPC and WebSocket. Both support bidirectional full-duplex communication and allow the server to push messages to the client without polling from the client side. However, beyond some similarities, gRPC and WebSocket have plenty of different characteristics, so the choice between them depends on exactly what you need for your project.
gRPC is an open-source framework that implements Remote Procedure Calls (RPC) over HTTP/2. It was initially developed as an internal project by Google but was publicly released in 2016 and is now in widespread use in many organizations as diverse as Netflix, Cisco, or Cockroach Labs.
The idea behind RPC is that a client program can call procedures or functions hosted on a remote server transparently, just as if they were implemented locally in a code library. The network code that connects the client and server is largely hidden from the programmer. However, the procedure call will generally take more time to execute than a local call because of the communication overhead.
You can define several different types of remote procedures with gRPC, but the most natural fit for full-duplex communication is a bidirectional streaming procedure. This provides a read-write data stream to both the client and the server. Both can consume and respond to separate sections of data as they arrive.
To specify the procedures and the data serialization format for parameters, gRPC uses Google's Protocol Buffers (Protobuf) as its interface description language. Protobuf (stored in a text file with a .proto filename extension) lets you define highly structured and compact binary data structures for parameters and return values. Google provides the
protoc compiler, which uses the
.proto file to generate code for parsing and accessing the binary data efficiently. The compiler supports several programming languages, including C++, Go, and Python, and there are also third-party compilers for Rust, Swift, and many others.
For communication between the client and server, the gRPC protocol uses HTTP/2, which is a huge improvement over HTTP/1.1 for efficiency. However, it can still involve significant amounts of header data and may require you to design your code to avoid losing connections during periods of inactivity.
gRPC + Protobuf performs much better than some alternatives, like REST + JSON communication.
protoccompiler generates a lot of the required code for you.
HTTP/2 uses multiplexing to transmit data efficiently.
Libraries are available in several languages, and the Protobuf format allows them to interoperate smoothly (so you can easily use clients and servers written in different languages).
Ptorobuf is not human-readable. This can make debugging and payload analysis more difficult than they would be with a human-readable format.
HTTP/2 still has some latency issues due to headers being used in each exchange.
Although apps can use the code libraries to access gRPC, web browsers don’t support it directly. This means you must use a proxy such as gRPC Web to support gRPC in browsers.
The WebSocket technology is a W3C standard that was introduced in 2008. A WebSocket connection is initiated by the client using an HTTP/1.1 request that gets "upgraded" by the server to a full-duplex, bidirectional communication channel. This connection persists until it is closed explicitly by either the client or the server, and, unlike HTTP, it imposes very little data transmission overhead. WebSocket is in widespread use by many companies, including HubSpot, Figma, and DAZN, to name just a few.
WebSocket can transmit both text (string) and binary data. The WebSocket protocol allows you to specify a subprotocol during the initial HTTP/1.1 handshake that can be used on top of WebSockets (for example, MQTT). Alternatively, you can define your own protocol on top of raw WebSockets if, say, you need custom data semantics or extra features such as publish/subscribe messaging.
Minimal transmission overhead. Unlike earlier HTTP-based approaches (such as long polling), the WebSocket protocol uses persistent connections rather than a continuous request/response cycle. When it comes to realtime communication, WebSockets require less bandwidth and provide lower latency compared to HTTP, reducing the load on both the client and the server.
You can use any text or binary data format for the data. You could choose a text format to simplify debugging or a compact binary format to maximize efficiency.
There are numerous libraries and frameworks implementing the WebSocket protocol across all programming languages and development platforms. Additionally, browsers natively support the WebSocket API, which is an advantage compared to gRPC.
As an event-driven technology, WebSocket allows data to be transferred without the client requesting it. This characteristic is desirable in scenarios where the client needs to react quickly to an event (especially ones it cannot predict, such as a fraud alert).
The WebSocket protocol is stateful. This can be tricky to handle, especially at scale, because it requires the server layer to keep track of each individual WebSocket connection and maintain state information.
WebSockets don’t automatically recover when connections are terminated – this is something you need to implement yourself, and is part of the reason why there are many WebSocket client-side libraries in existence.
Certain environments (such as corporate networks with proxy servers) will block WebSocket connections.
WebSocket and gRPC are both realtime communication technologies with some similarities, but also plenty of differences. They have distinctive characteristics and other trade-offs that you should consider, and they’re mainly designed for different use cases.
With gRPC, the .proto file defines and documents the binary data format explicitly. The binary format is compact, and you can tailor it very precisely to suit your needs. Some effort is required to design it, but this might be worthwhile if the data or infrastructure is complicated (for example, if you have existing components written in different programming languages).
WebSocket has no “official” format specification - it can use any binary or text format. You can use standard options like JSON, Protobuf, and MessagePack, or create your own custom format if necessary.
Although HTTP/2 (used by gRPC) is a great improvement over HTTP/1.1, it still incurs some latency from headers and from reconnecting after periods of inactivity. This means that gRPC communication might experience increased latency compared to WebSockets. However, gRPC will generally have good throughput because of the efficient binary format, and because HTTP/2 supports multiplexing.
WebSocket uses a persistent TCP connection that is normally closed only when communication is finished. It also keeps headers to a minimum, only requiring them for the initial HTTP/1/1 handshake. You can use multiplexing with WebSocket to improve performance, but you must either use a third-party library or support it in your own code, and both options add complexity to your project.
gRPC supports Transport Layer Security (TLS) for encryption and authentication. Note that you can use Google's ALTS variant of TLS (when the app is running on the Google Cloud Platform). You can also use token-based authentication (such as OAuth2) as an extra level of security for your gRPC application.
With WebSocket, you can use TLS for encryption via the
wss: URL scheme (similar to https). WebSocket doesn't impose any particular authentication method; you can use any of the methods that are typically available for HTTP, such as cookies, HTTP authentication, or TLS authentication. You can also implement your own mechanism (such as token-based authentication) if this suits your needs better.
WebSocket is a stateful protocol, which relies on both sides (but especially the server) storing information about the connection state and history of previous messages. You need more complex code to keep track of the state; additionally, the client can only communicate with a server process that has access to the current state. This can make it hard to scale out to a large number of WebSocket connections (for example, load balancing between servers is tricky). That’s not to say you can’t scale to handle millions of concurrent WebSocket connections; it’s just incredibly difficult to do it right.
HTTP ( used by gRPC) is stateless, meaning that any information needed to maintain communication gets retransmitted with each request/response exchange. Although this involves inefficient repetition of data in the headers, it also ensures that server processes are interchangeable, since none of them needs to remember anything about the clients they are communicating with. Consequently, scaling up to large numbers of connections is somewhat less complex than scaling WebSockets. However, as WebSockets are generally less resource-intensive than HTTP and more efficient at transmitting data, scaling a gRPC system requires more computing power and bandwidth compared to scaling a WebSocket-based system of similar size.
Whether you should use gRPC or WebSockets depends on the specifics of your use case. Below, we list the most common scenarios where gRPC / WebSocket is a strong choice.
Connecting polyglot services in a microservices-style architecture.
Connecting client devices (e.g., mobile devices) to backend services (ideally use cases that don’t involve high-frequency data updates).
Connecting point-to-point realtime services that need to handle streaming requests or responses.
Realtime updates, where the communication is unidirectional, and the server is streaming low-latency (and often frequent) updates to the client. Think of live score updates, newsfeeds, alerts, and notifications, to name just a few use cases.
Bidirectional communication, where both the client and the server send and receive messages. Examples include chat, virtual events, and virtual classrooms (the last two usually involve features like live polls, quizzes, and Q&As). WebSockets can also be used to underpin multi-user synchronized collaboration functionality, such as multiple people editing the same document simultaneously.
Fanning out (broadcasting) the same message to multiple users at once. Various WebSocket libraries implement broadcasting over WebSockets (usually via pub/sub messaging). In contrast, gRPC does not natively support broadcasting.
WebSocket and gRPC are two key realtime technologies, often used in modern software development. We hope this article has helped you understand the differences and similarities between WebSocket and gRPC, and what kind of use cases they are suitable for.
If you’re looking to see how WebSocket compares to other realtime technologies, check out the following:
Ably is a serverless WebSocket platform that powers realtime communication for web, mobile, and IoT apps. We make it easy for developers to build live and collaborative experiences for millions of users in a few lines of code, without the hassle of managing and scaling WebSocket infrastructure. Our platform is underpinned by a globally-distributed, autoscaling network consisting of 16 datacenters and 307 edge acceleration points of presence.
We provide robust capabilities and guarantees, including 25+ client SDKs targeting every major development platform and programming language, feature-rich pub/sub APIs, guaranteed message ordering and delivery, and global fault tolerance.
To find out more about what Ably can do for you, get started with a free account.
Developing a dependable client-side WebSocket solution for Unity
Learn about the many challenges of implementing a dependable client-side WebSocket solution for Unity to deliver realtime data.
AMQP is not two versions of the same protocol, but two entirely different protocols: one is called "0-9-1", and the other "1.0". This intro is about AMQP 1.0.