The four API styles between which an API architecture is decided do not rest on texts of the same kind. REST is an architectural style described in 2000 in a doctoral dissertation. GraphQL is a specification published in successive editions. gRPC is an open source software framework, described by its documentation. Event-driven APIs can be described with a specification, AsyncAPI, which does not define the style itself.
We call API architecture here the set of choices by which an information system exposes its functions and data to other software: the style of each exchange, the form of its contract, its rules for evolution and security. None of the four styles wins in general: each exposes a different object, leaves different work to the consumer and calls for different governance. An API strategy then sets, for the whole information system, which styles are permitted for which exchanges and which rules apply to all. Sources consulted on 12 November 2026.
Four styles, four exposed objects
REST is defined in chapter 5 of Roy Fielding’s dissertation, “Architectural Styles and the Design of Network-based Software Architectures” (University of California, Irvine, 2000). The style is built there through successive constraints: client-server, stateless, cache, uniform interface, layered system, and code on demand, the only optional constraint. The uniform interface brings together four: identification of resources, manipulation of resources through representations, self-descriptive messages, hypermedia as the engine of application state. The exposed object is therefore a resource. The dissertation states that REST does not restrict communication to a particular protocol, and the chapter summary (section 5.5) attaches its properties to these constraints “when applied as a whole”.
The GraphQL specification, in its September 2026 edition, presents itself as a query language and an execution engine. A service publishes a typed schema and supports three operations: the query (read), the mutation (write followed by a read) and the subscription, a long-lived request that receives data as events occur. According to the GraphQL Foundation’s page, the language was created in 2012 and open-sourced by Facebook in 2015; the foundation, created in 2019, is hosted by the Linux Foundation.
gRPC, according to its documentation, allows a client to call a method on a remote server “as if it were a local object”. The service is defined by its methods, their parameters and their return types, by default in Protocol Buffers. The documentation distinguishes four kinds of methods: unary call, server streaming, client streaming, bidirectional streaming. Born at Google according to its website, the project was accepted by the CNCF on 16 February 2017 at the “Incubating” maturity level, according to the CNCF’s project page.
AsyncAPI, version 3.1.0, describes message-driven APIs in a machine-readable format, whatever the protocol (AMQP, MQTT, WebSockets, Kafka, among others). The exposed object is a message, published on a channel by a sending application and received by receiving applications. Our entry on event-driven architecture presents the exchange patterns.
The work left to the consumer
In REST, the client follows the uniform interface and carries the session state: each request must contain all of the information necessary to understand it (section 5.1.3). The dissertation names the trade-off of the uniform interface: it degrades efficiency, since information is transferred in a standardised form rather than one specific to an application’s needs (section 5.1.5).
In GraphQL, the client writes its query field by field, and the response contains, according to the specification, exactly what it asked for, and nothing more. It discovers the schema by introspection, and its query is validated against the type system before execution. In our reading, the burden shifts: the producer no longer knows the shape of the queries in advance.
In gRPC, the client has a “stub” that exposes the same methods as the server. It generates it in its own language from the .proto file shared with the producer. For streams, the documentation guarantees message ordering within a single call.
With events, the consumer subscribes to a channel and processes messages whose sender does not need to know the recipients. AsyncAPI presumes no topology: ordering and delivery guarantees depend, in our reading, on the protocol and server chosen.
Contracts, governance and limits side by side
| REST | GraphQL | gRPC | Events | |
|---|---|---|---|---|
| Exposed object | Resources and their representations | Typed schema, queried by requests | Service methods | Messages published on channels |
| Contract description | OpenAPI for an HTTP API; the dissertation imposes no format | The schema, readable by introspection | .proto file | AsyncAPI |
| Evolution provided for by the source | Independent evolution of components (dissertation, 5.1.5) | @deprecated directive on a field | Not found in the pages read | Mandatory API version field (info.version) |
| Governance we propose | Owner per resource, published description | Schema owner, review of additions and removals | Shared repository of .proto files, compatibility rules | Channel catalogue, owner per message |
| Limit | Interface not optimal outside hypermedia transfer (dissertation) | Query cost to be controlled by the producer (our reading) | Generated code on both sides (our reading) | Consumers updated with a delay (our reading) |
The OpenAPI specification, version 3.2.1 of 10 September 2026, defines a standard, programming language-agnostic interface description for HTTP APIs. The table compares no performance, which depends on loads and implementations and is measured on the organisation’s own case.
A place for each style
In our reading, REST suits cases where consumers are numerous, sometimes unknown, and where intermediaries must be placed in between: according to the dissertation, the layered system constraint allows intermediaries to be introduced (“proxies, gateways, and firewalls”). An API gateway is one of them.
GraphQL suits screens whose needs vary: its specification describes itself as driven by the needs of views and of the developers who write them (“product-centric”).
gRPC suits calls between services whose teams share a contract file and supported languages, particularly for bidirectional streams.
Events suit cases where the sender can publish without waiting for its recipients. Our IT architecture page compares this integration mode with synchronous calls and file exchanges.
A single domain can expose two styles, each for its own consumers. The choice and its reasons are recorded in an architecture decision record (ADR).
An API strategy at the scale of the information system
The API strategy makes these choices consistent from one project to the next. We propose that it set five rules.
- The permitted styles, and for each the exchanges it suits, based on criteria such as those in the table.
- One contract format per style (OpenAPI, AsyncAPI, GraphQL schema, .proto file) and the place where contracts are published. The inventory, the portal and versions fall under API management.
- A named owner for each API and each channel.
- Common security rules: exposure through a gateway for external consumers, authentication of services with one another, for example through mutual TLS.
- An exemption procedure, examined through an ADR and reviewed when it falls due.
It relies on the integration rules and the architecture body described in our service page, and is reread when an ADR requests a style that the rule does not permit: the exemption shows whether the rule still matches the exchanges of the information system.