Pick GraphQL when many clients consume the API and each wants different fields. Pick tRPC when you control both ends in a TypeScript monorepo and want types to flow without a schema layer. If neither shape fits, REST is the default and gRPC is the choice for internal services — see our gRPC vs REST page for that side of the decision.
This is the modern API-protocol decision and it has four serious contenders: REST, GraphQL, tRPC, and gRPC. REST is the universal default for any audience that isn't you (covered on a separate page); gRPC is the binary-internal choice (also covered separately). The interesting modern choice for app developers is GraphQL vs tRPC — flexible client-driven queries vs zero-friction TypeScript types. Pick by what shape your client situation has.
A query language and a schema. Clients send queries to a single endpoint specifying exactly the fields they need; the server resolves and returns matching shape. One endpoint, many shapes.
Typed RPC over HTTP. Server defines procedures (queries + mutations); clients call them like normal TypeScript functions. Types flow via TypeScript inference, no schema needed.
Schema-first typing. SDL (Schema Definition Language) defines types; codegen (graphql-codegen) produces client types. Generated, not inferred — has to be re-run on schema change.
TypeScript inference end-to-end. The client gets types from the server's implementation with no codegen step. Changes are reflected immediately. Only works if both ends are TS.
Original design goal. Clients request exactly the fields needed; server returns only those. Massive bandwidth wins on mobile or low-bandwidth contexts.
Each procedure returns its predefined shape. To get a subset, the server has to define a new procedure or the client has to call multiple. Less elegant for selective fetching.
Servers and clients in any language. Apollo, urql, Relay for JS; gqlgen for Go; Graphene for Python; Hot Chocolate for .NET; Hasura / PostGraphile for instant Postgres APIs.
TypeScript only. Server in TS, client in TS. Trying to consume a tRPC API from Python or Go means writing the request manually — no types, no inference.
Mature ecosystem: GraphiQL, Apollo Studio, Hasura Console, GraphQL Yoga, Pothos. Schema explorer is universal. Excellent developer experience for external API consumers.
Light by design. TanStack Query integration is the headline feature. No introspection UI, no schema browser — but also no schema to browse.
Subscriptions are first-class in the spec. graphql-ws transport is standard. WebSocket-based, with reconnection, multiplexing, and auth all defined.
Subscriptions exist (since 10.x) using a WebSocket link or Server-Sent Events. Working but requires setup; not as polished as the GraphQL story.
High. Schema definition, resolvers, DataLoader for N+1, query depth limits, complexity analysis. Real ops surface — every Apollo Server outage post-mortem is a teachable moment.
Low. `t.procedure.input(z.object({...})).query(({input}) => ...)`. That's the entire API. No schema files, no resolvers, no complexity analysis.
Used at Meta, Netflix, Airbnb, GitHub, Shopify. Huge installed base. Server-side caches (Apollo, Hasura) are production-grade. Has been in production for a decade.
Used by smaller startups, Cal.com, Vercel's own work. Growing fast in the Next.js/SvelteKit ecosystem. About 5 years old. Not used at the biggest tech companies (because they aren't TS-only).
Identical Node.js server, 1 KB user payload, 100 concurrent clients via autocannon. GraphQL using Apollo Server 4, tRPC v10 with HTTP batched link, REST + gRPC for context.
Full-stack TypeScript app, single team owns both ends
tRPC removes a whole category of API boilerplate. Types flow from server to client with no codegen step. Pair with TanStack Query for caching.
Public API with many third-party consumers
GraphQL's schema is a contract; the introspection story is excellent for external developers. Codegen exists for every language.
Mobile app + web app + partner integrations from one backend
Each client picks exactly the fields it needs. Bandwidth wins on mobile, version drift handled by the schema.
B2B SaaS dashboard, internal team, fast iteration
tRPC + Next/SvelteKit + Prisma is the fastest path to shipping. Refactoring server fields shows compile errors in the client immediately.
Internal microservices in a polyglot backend (Go + Python + Java)
tRPC is TS-only. GraphQL is overkill for service-to-service. gRPC with .proto contracts is the standard answer — see our gRPC vs REST page.
Public REST API, no need for query flexibility
REST is still the default for public APIs. Skip GraphQL's complexity tax if your clients don't need its flexibility. Document with OpenAPI.