# A2A JSON-RPC vs gRPC vs REST: What Differs Between the Three Bindings

> The three A2A protocol bindings (JSON-RPC, gRPC, HTTP+JSON/REST): what the specification keeps identical, what differs on the wire, and an inference-labelled guide to picking one.

Guide: A2A in practice: agent-to-agent interoperability — part 4
Published: 2026-11-02 · Updated: 2026-11-03 · 912 words · ~1213 tokens (estimate)
Canonical: https://changegamer.ai/articles/a2a-bindings-json-rpc-grpc-rest
JSON: https://changegamer.ai/api/articles/a2a-bindings-json-rpc-grpc-rest.json
Access: free — editorial guide, not part of the licensed corpus
Pillar: https://changegamer.ai/articles/a2a-protocol-in-practice.md

## In short

- A2A v1.0 defines three protocol bindings, JSON-RPC, gRPC and HTTP+JSON/REST, and an agent that offers more than one of them must keep their behavior aligned under the specification.
- Equivalence in A2A means the same operations and capabilities, semantically equivalent results and consistent protocol-specific error mapping, so the specification requires the same operations and results across bindings while the wire format and the streaming exposure still differ.
- Real-world usage share across the A2A bindings could not be confirmed from any source found when the ChangeGamer corpus was verified in October 2026, because the specification mandates equivalence, not adoption reporting.
- A2A is not JSON-RPC only: an A2A agent may publish a gRPC or an HTTP+JSON/REST interface, and the HTTP+JSON binding uses the application/a2a+json media type.
- Which A2A binding to pick is, as inference, a question about the infrastructure you already operate, since the specification keeps the capabilities the same across all three.

---

The three A2A bindings are JSON-RPC, gRPC and HTTP+JSON/REST, and what separates them is mainly the wire format (inference from the equivalence rule). The [A2A protocol reference](/resources/a2a-protocol) (updated 27 October 2026) lists them; the [pillar](/articles/a2a-protocol-in-practice) covers the protocol overall. Here the angle is narrower: what the specification holds constant, what moves, and how to choose. Authentication per binding is a separate topic ([A2A authentication schemes](/articles/a2a-authentication-schemes)) and is not covered.

## What does A2A keep the same across its bindings?

A2A keeps the capability set constant: v1.0 obliges any agent that offers several bindings to keep them aligned. The [MCP vs A2A reference](/resources/mcp-vs-a2a) attributes the rule to the specification's binding sections and splits it into three parts:

- the same operations and capabilities;
- semantically equivalent results;
- consistent protocol-specific error mapping.

Two limits apply. The rule is conditional: it constrains an agent that offers several bindings, and the reference does not say an agent must offer all three. And it is a mandate, not a measurement; the reference does not say how closely deployed agents honor it.

### Why the message-format row in comparisons is not the whole picture

The MCP vs A2A comparison table lists A2A's message format as JSON-RPC 2.0, unqualified. Read it alongside its own transport row, which lists all three bindings, and with the equivalence rule above: that row describes the JSON-RPC binding and, as inference, is not a limit on A2A. As inference, a client that assumes every A2A agent speaks JSON-RPC would fail against an agent that publishes only gRPC.

## What differs between the A2A bindings?

The bindings differ in transport, in how operations are named, and in how streaming is exposed, and the reference records some of each. As of 2 November 2026, this is what the corpus supports:

| Binding | Transport and encoding | How an operation is named | Streaming |
|---|---|---|---|
| JSON-RPC | JSON-RPC 2.0 | Method names in PascalCase, such as `SendMessage` | Server-Sent Events, per the reference |
| HTTP+JSON/REST | HTTP with `application/a2a+json` bodies | Resource paths and verbs, such as `POST /message:send` | The reference does not say |
| gRPC | Protocol Buffers v3 over HTTP/2 with TLS | Service `A2AService` (normative) | The reference does not say |

The reference lists 7 of the 11 operations for JSON-RPC and for HTTP+JSON; the four push-notification config operations are not listed in either spelling set, and it gives no per-operation spellings for gRPC. Do not assume the full set is identical in every binding. Check the specification for the operation you need, and for any binding you plan to expose, confirm the exact spelling of each operation against the version named in your `A2A-Version` header before you generate client code from it.

### What "HTTP+JSON/REST" means

HTTP+JSON/REST is the reference's single name for the third binding, whose operations are resource paths such as `GET /tasks/{id}`. This article writes "HTTP+JSON" for short and means the same binding; the reference does not explain the slash. A custom binding is also allowed; the reference does not describe how one is defined.

## Which A2A headers and media types depend on the binding?

Two strings are worth hard-coding carefully: the `A2A-Version` header and the `application/a2a+json` media type. Clients send `A2A-Version` in the form `Major.Minor`, or as a request parameter of the same name, and servers answer `VersionNotSupportedError` for versions they do not support. An empty header value is interpreted as `0.3`, so check that your client never sends one. Patch numbers are not negotiated.

The v1.0.1 patch (28 May 2026) prefers `application/a2a+json` in the HTTP binding. The reference does not say whether the header applies identically to gRPC, so verify that against the specification before relying on it.

For older material, the v0.3.0 release (30 July 2025) is the release whose JSON-RPC spellings older documentation shows as `message/send` and `message/stream`; migration is covered in [the v0.3 to v1.0 migration](/articles/a2a-v0-3-to-v1-0-migration).

## Which A2A binding should you pick? (inference)

Pick the binding your existing infrastructure already runs, because the specification keeps capabilities equal across all three. Every row below is inference, each with a one-line reason; none comes from the reference.

| Situation | Pick (inference) | Reason (inference) |
|---|---|---|
| You already run gRPC services and control both ends | gRPC | Reuses the stack and tooling you operate |
| Third parties call you through a public gateway | HTTP+JSON | Fits HTTP infrastructure that already inspects and routes requests |
| Your framework or SDK already speaks JSON-RPC, as MCP does | JSON-RPC | Reuses client code your team knows |
| You do not know your callers yet | One binding you can operate | Equivalence lets you add a second later when a real client needs it |

If you do publish two, test both against the same fixture. The equivalence rule is the specification's promise, and (inference) your implementation is the most likely place it can fail. Whichever you choose, list it in the Agent Card; [the Agent Card design article](/articles/a2a-agent-card-design) covers the interface fields, and the [task lifecycle article](/articles/a2a-task-lifecycle) covers the operations themselves.

## Does ChangeGamer implement any A2A binding?

No. As of 2 November 2026, a grep for `SendMessage`, `message:send`, `A2AService`, `grpc` and `agent-card` across `changegamer/src/pages`, `src/lib`, `src/layouts`, `src/components`, `worker/` and `public/` returns zero matches. The site speaks MCP over JSON-RPC and implements no A2A endpoint, so the guidance above is reasoning from the reference, not from running a binding in production.

## Frequently asked questions

### Is A2A only JSON-RPC?

A2A is not JSON-RPC only: A2A v1.0 defines three bindings, JSON-RPC 2.0, gRPC and HTTP+JSON/REST, and also allows custom bindings. JSON-RPC is one way to reach the same operations, not the only one, according to the A2A reference in the ChangeGamer corpus.

### Do JSON-RPC, gRPC and REST give the same results in A2A?

An A2A agent that publishes several bindings must return matching outcomes through each of them. The v1.0 specification states this as a requirement on operations, results and error mapping, and it is a rule in the specification, not a measurement of how deployed agents behave.

### Which A2A binding do most agents use?

Which A2A binding most agents use could not be confirmed from any source found when the ChangeGamer corpus was verified in October 2026. The specification mandates behavioral equivalence, not adoption reporting, so treat any claim that one A2A binding dominates in production as unverified.

### What media type does the A2A HTTP+JSON binding use?

The A2A HTTP+JSON binding uses application/a2a+json for its bodies, and the v1.0.1 patch released on 28 May 2026 prefers that media type, according to the A2A reference in the ChangeGamer corpus.


---

## The rest of this guide

- [The A2A Protocol in Practice: Agent Cards, Tasks, Auth and When You Need It](https://changegamer.ai/articles/a2a-protocol-in-practice.md): A practical guide to the A2A (Agent2Agent) protocol: what it standardizes, when it beats in-process subagents, how Agent Cards, task states, bindings and authentication work, how credentials cross agent hops, and how to launch it.
- [Do You Need A2A for a Multi-Agent System? A Decision Rule](https://changegamer.ai/articles/do-you-need-a2a.md): A decision rule for choosing between in-process subagents and the A2A protocol: start with one agent, add more only for a named failure, and cross the network with A2A only when a remote party, framework or trust boundary demands it.
- [Designing an Agent Card: What Goes in the Public Card and What Waits](https://changegamer.ai/articles/a2a-agent-card-design.md): How to design an A2A Agent Card: the field groups, the well-known path, optional signing, and a rule for splitting what the public card advertises from what an authenticated client fetches in the extended card.
- [A2A Task States and Operations: What Each State Means for an Orchestrator](https://changegamer.ai/articles/a2a-task-lifecycle.md): The eight A2A task states, the eleven operations that act on tasks, the difference between interrupted and terminal states, and an inference-labelled handler matrix for an orchestrator.
- [A2A Authentication Schemes: Which to Declare in Your Agent Card](https://changegamer.ai/articles/a2a-authentication-schemes.md): The five security scheme families an A2A Agent Card can declare (API key, HTTP auth, OAuth 2.0, OpenID Connect, mutual TLS), an inference-labelled rule for choosing one, and how a client handles auth-required tasks.
- [Credential Propagation Across Agent Hops: Exchange, Audience and Depth](https://changegamer.ai/articles/credential-propagation-across-agent-hops.md): How to carry authority through a chain of delegating agents: why forwarding a token fails, per-hop RFC 8693 exchange with act and may_act, RFC 8707 audience binding, a worked sequence and a failure walk-through.
- [How to Verify a Remote A2A Agent Before Delegating](https://changegamer.ai/articles/trusting-a-remote-agent.md): What a signed Agent Card proves and does not, how domain, key and ERC-8004 identity differ, where Web Bot Auth fits, and why card text and returned artifacts are untrusted input, ending in an ordered checklist.
- [How Do Agents Discover A2A Agents Without a Standard Registry?](https://changegamer.ai/articles/a2a-agent-discovery-without-a-registry.md): The three discovery strategies in the A2A documentation, why the spec prescribes no registry API, what vendor registries fill the gap, and how to choose between a well-known URI, a registry and direct configuration.
- [Migrate A2A v0.3 to v1.0: An Ordered Checklist for Clients and Servers](https://changegamer.ai/articles/a2a-v0-3-to-v1-0-migration.md): An ordered checklist for moving an A2A client or server from v0.3 to v1.0: the A2A-Version header rule, method names, Part shape, a runnable grep check, and symptom-to-cause pointers.
- [Does Your Agent Framework Really Support A2A? How to Read the Claim and What to Test](https://changegamer.ai/articles/agent-frameworks-with-a2a-support.md): Which agent frameworks list A2A support, what native, add-on, platform-gated and unrecorded mean, a short test checklist to run before you rely on it, and how that differs from the protocol's own SDKs.
- [Failed or Rejected Remote A2A Task: Retry, Degrade or Surface?](https://changegamer.ai/articles/failure-handling-across-agent-boundaries.md): How to decide what happens after a remote A2A task ends badly: the side-effects test that splits failed into retry or surface, why rejected is not a retry case, why input-required is not a failure, and a structured result for the caller.
- [A2A Production Launch Checklist: Gates to Pass Before You Ship](https://changegamer.ai/articles/a2a-production-launch-checklist.md): A go/no-go checklist for launching A2A agent-to-agent delegation, one line per gate, each pointing to the article that owns the detail: need, card, states, binding, auth, trust, versioning, failure.

## Reference resources

- https://changegamer.ai/resources/a2a-protocol.md
- https://changegamer.ai/resources/mcp-vs-a2a.md

All guides: https://changegamer.ai/api/articles.json · Reference corpus: https://changegamer.ai/llms.txt
Licensing: https://changegamer.ai/api/pricing.json (offer catalog) · https://changegamer.ai/api/payment.json (payment methods, HTTP 402 flow) · access guide: https://changegamer.ai/resources/access-and-pricing.md
