OOmnistu

Blog / Engineering Playbooks

Engineering Playbooks

gRPC vs REST-style HTTP APIs: choosing an API approach

REST is an architectural style, not a protocol; in practice it usually means a resource-oriented HTTP API with JSON bodies. gRPC is an RPC framework over HTTP/2 with protobuf as its default format and generated clients. Where each fits, including gRPC-Web's browser limits, from grpc.io's own documentation, read 21 November 2026.

OOmnistu
Reviewed 2026-11-21 · 4 min read

Per grpc.io's own documentation, read 21 November 2026: this comparison needs one correction up front, because the shorthand hides it. REST is not a protocol - it is an architectural style, and what most teams call "a REST API" is really a resource-oriented HTTP API with JSON bodies. gRPC is a concrete RPC framework that, per its own FAQ, "largely follows HTTP semantics over HTTP/2". So the real decision is gRPC against the common REST-style HTTP JSON API, and that is what this article compares, with no default winner. If your question is instead about push channels, see our WebSockets vs Server-Sent Events piece; if it is about query flexibility, see GraphQL explained.

What each one actually is

A REST-style HTTP API models resources with URLs, acts on them with HTTP methods, and usually exchanges JSON documents - human-readable, curl-able, debuggable in any browser's dev tools, and understood by essentially any HTTP client library. gRPC works differently: you define your service once in a .proto file, and per its introduction page, gRPC uses Protocol Buffers by default "as both its Interface Definition Language (IDL) and as its underlying message interchange format" - though it can be used with other data formats such as JSON. From that definition, gRPC generates client and server code in its supported languages, and per the gRPC-Web basics page, "all the complexity of communication between different languages and environments is handled for you by gRPC". Protobuf messages are binary: compact and schema-checked, but not something you can eyeball in a packet capture the way you can JSON.

Streaming: four modes, with a browser asterisk

gRPC's core concepts page defines four kinds of RPC: unary (single request, single response, "just like a normal function call"), server streaming (one request, a stream of messages back), client streaming (a stream of messages in, one response), and bidirectional streaming (both sides stream independently), with message ordering guaranteed within an individual RPC call, per that page. That is a genuinely different capability set from the request-response shape of a typical HTTP JSON API. The asterisk is the browser. Per the gRPC-Web basics page, browser code reaches gRPC services through gRPC-Web, typically behind a proxy (its example uses Envoy forwarding browser requests to the backend). And per the grpc/grpc-web repository's own README, client-side and bidirectional streaming are "not currently supported" there - gRPC-Web supports unary and server-side streaming calls. So the full four-mode story applies to native clients; a browser-heavy product gets two of them today, per that repo.

Different conventions, not just different bytes

gRPC's FAQ is candid about diverging from REST conventions: it uses static paths "for performance reasons during call dispatch", because parsing call parameters from paths, query parameters and payload body "adds latency and complexity", and it formalizes its own set of errors rather than reusing HTTP status codes, which it considers "more directly applicable to API use cases". That is the vendor's stated rationale - treat it as their engineering argument, not a settled benchmark. The mechanisms behind gRPC's reputation for speed are real (binary framing, HTTP/2 transport, generated marshalling code), but there is no honest universal "gRPC is faster": payload sizes, caching, proxies and team familiarity routinely matter more than the wire format. Meanwhile the REST-style side carries its own strengths: HTTP caching semantics, ubiquitous tooling, and the fact that any third party can integrate with a JSON HTTP API using whatever language and HTTP library they already have.

How the choice usually plays out

Internal service-to-service calls inside one organization, especially polyglot microservices or workloads that need streaming: gRPC is the natural fit - one .proto definition, generated clients on both ends, four streaming modes for native clients. A public API for unknown third parties, or anything a browser calls directly: a REST-style HTTP JSON API is the common default, because clients already speak it without generated stubs. A browser app backed by gRPC services: gRPC-Web with a proxy works, but per its repo you get unary and server-side streaming today - if you need client or bidirectional streaming from a browser, that is a different architecture decision (and our WebSockets vs SSE piece covers browser push channels). A small team shipping one API where debugging with curl matters: JSON over HTTP keeps the tooling bill at zero.

Sources, all read 21 November 2026: grpc.io, Introduction to gRPC (protocol buffers as default IDL and message format, other formats such as JSON possible); grpc.io, Core concepts (four RPC kinds quoted; ordering guaranteed within an individual RPC call); grpc.io, FAQ (HTTP semantics over HTTP/2; static paths for performance reasons during call dispatch; formalized error set over HTTP status codes); grpc.io, gRPC-Web basics (browser access via gRPC-Web, Envoy proxy example); grpc/grpc-web repository README (client-side and bidirectional streaming "not currently supported"; unary and server streaming supported); protobuf.dev, proto3 language guide (message and field structure).

Designing service-to-service APIs? Omnistu's Backend and APIs practice works on services, integrations and the data models behind your product - write to team@omnistu.com with what you are deciding.

Frequently asked questions

Is REST a protocol?

No. REST is an architectural style, not a protocol, and it is not inherently tied to JSON or any single HTTP version. In everyday usage "a REST API" usually means a resource-oriented HTTP API exchanging JSON - that common implementation is what this article compares gRPC against.

Is gRPC only usable with Protocol Buffers?

Protobuf is the default, not the only option. Per grpc.io's introduction, gRPC uses Protocol Buffers by default as both its IDL and its message interchange format, but it can be used with other data formats such as JSON. Most real deployments use protobuf, which is also where the compact binary payloads and schema-checked code generation come from.

Can a browser call a gRPC service directly?

Not directly - the browser path is gRPC-Web, which per grpc.io's basics tutorial typically runs behind a proxy (its example uses Envoy) that forwards browser requests to the gRPC backend. And per the grpc/grpc-web repository, gRPC-Web currently supports unary and server-side streaming calls; client-side and bidirectional streaming are "not currently supported". Check that repo for the current state before designing around it.

Is gRPC always faster than a REST-style API?

There is no honest universal answer. The mechanisms behind gRPC's performance reputation are real - binary framing, HTTP/2 transport, generated marshalling code, and per its FAQ static paths chosen "for performance reasons during call dispatch" - but payload sizes, HTTP caching, proxy behavior and team familiarity routinely matter more than the wire format. Benchmark your own workload before letting this decide.

Which should a public API use?

A REST-style HTTP JSON API is the common default for public APIs: any language with an HTTP client can use it, third parties need no generated stubs, and debugging is a curl command. gRPC is common for internal service-to-service APIs inside one organization, where both ends are yours and its generated clients plus streaming modes pay off.

Is this the same decision as GraphQL vs REST?

No. GraphQL is a query language where the client describes the data it needs - a different axis from wire protocol. gRPC vs REST-style HTTP is about how calls are defined and transported. Our GraphQL explainer covers the query-language axis.