tRPC

tRPC is the open-source TypeScript framework that lets a Next.js, Express, Fastify or Bun server expose typed procedures and have those types flow into a React, React Native or Vue client with zero schemas, zero codegen and zero generated SDKs. We rate it 82/100 — for full-stack TypeScript monorepos, tRPC v11 is still the cleanest end-to-end developer experience on the market, even as Server Actions and TanStack Start chip away at its core pitch.

What is tRPC?

tRPC was created in 2020 by Swedish developer Alex "KATT" Johansson, building on a tiny ZodRPC proof of concept by Zod author Colin McDonnell. The core idea is almost unfair: define a server router as a plain TypeScript object, import its type on the client, and TypeScript inference does the rest — autocomplete, parameter validation, return-type narrowing, error types — all without a single OpenAPI file, GraphQL schema or generated client.

The project is MIT-licensed, lives at github.com/trpc/trpc with around 40,000 GitHub stars, and ships its current major version, v11, since March 21, 2025. The 2026 release line (v11.13.x → v11.14) added OpenAPI JSON generation for any tRPC router, a `streamHeader` option for `httpBatchStreamLink`, and a documentation revamp.

Key Features of tRPC

• Type inference, no codegen: server router types travel to the client as a single TypeScript import — no `tsc`-driven build step, no contract files, no `openapi-generator` waiting in CI.
• Adapters for every major runtime: first-party packages for Next.js (Pages and App Router), Express, Fastify, AWS Lambda, standalone HTTP, and a Fetch adapter that covers Astro, Remix, SolidStart, Cloudflare Workers, Bun and Vercel Edge.
• TanStack React Query integration: v11 introduced a rebuilt TanStack Query integration on February 17, 2025, with first-class support for caching, optimistic mutations, query invalidation, infinite queries, suspense and prefetch helpers in Server Components.
• Subscriptions over SSE: v11 added Server-Sent Events as a built-in transport — auto-reconnect, no separate WebSocket server required for most real-time use cases.
• Schema-library agnostic validators: Zod, Valibot, Yup, Superstruct, Arktype or plain functions all work as runtime input validators, so teams aren't locked into one schema dialect.
• Non-JSON content types: v11 also unlocked `FormData`, `Blob`, `File` and `Uint8Array` over the wire — file uploads finally work without leaving the typed pipeline.

What Users Say About tRPC

Sentiment in TypeScript circles is positive but increasingly nuanced. On Hacker News, builders shipping production apps describe tRPC in glowing terms — one commenter on the v11 launch thread wrote that they had used it across two roughly 50,000-line web apps and "love it." Reddit threads on r/typescript and r/nextjs repeatedly praise the way tRPC eliminates the "API contract" as a separate artifact. Recurring criticisms are real, though: GitHub Discussion #2448 catalogues TypeScript IDE slowdowns on routers with around 40 endpoints and heavy Zod schemas; Issue #5249 documented an 18 KB bundle-size regression between v10.44.1 and v10.45.0; and Discussion #1860 captures a long-running gripe that tRPC essentially assumes a TypeScript monorepo, so non-monorepo users end up publishing private npm packages of types just to share a router. Most pointedly, mindshare is shifting — one HN comment titled "I'm currently in the process of removing tRPC from our codebase" framed Server Actions and TanStack Start server functions as good-enough replacements for simple Next.js apps. tRPC's defenders push back that those alternatives still don't match its caching, batching and multi-client story.

tRPC Pricing

tRPC is free and open source under the MIT license. There is no commercial tier, no SaaS layer, and no enterprise upsell.

Plan	Price	Includes
OSS (MIT)	$0	Full framework, all adapters, community support via GitHub Discussions and Discord
GitHub Sponsor — Backer	From $5/month	Public sponsor recognition
GitHub Sponsor — Pro tier	From $50/month	Recognition; higher tiers include a one-off onboarding call with the core team

Who Should Use tRPC?

Best for: small-to-mid-size product teams shipping a TypeScript backend and TypeScript frontend in the same monorepo, especially when they already use React Query, Next.js or a Bun/Hono fetch-based runtime and want zero contract drift.

Not ideal for: public APIs that need a published spec, polyglot teams with non-TypeScript clients, very large routers where TS IDE performance matters, or simple Next.js apps where Server Actions plus a couple of validated mutations are enough.

Pros and Cons

Pros:

• End-to-end types with no build step beats every codegen workflow we've benchmarked for iteration speed.
• Adapter coverage is unusually broad — Next, Express, Fastify, Lambda, Workers, Bun and edge runtimes all supported.
• v11's SSE subscriptions and FormData support fix the two most common real-world gaps from v10.
• Truly zero-cost — MIT license, no telemetry, no sponsor gating.

Cons:

• TypeScript performance degrades on big routers with heavy Zod usage, per ongoing GitHub discussions.
• Strongly assumes a TS monorepo; cross-repo type sharing remains awkward.
• Mindshare is being squeezed by Server Actions, TanStack Start server functions and Hono's typed `hc` client.
• No first-class OpenAPI output until 2026 — and the new generator is still maturing.

Alternatives to tRPC

Compared with GraphQL, tRPC trades cross-language tooling and introspection for pure TypeScript inference. Versus a REST + OpenAPI codegen workflow, tRPC removes the build step but loses a published contract. Hono RPC with the `hc` client is leaner and edge-native but ships a thinner ecosystem. Next.js Server Actions are zero-config for in-app mutations; TanStack Start server functions cover most of tRPC's territory inside a Start app. ts-rest and the newer oRPC are the contract-first challengers worth watching.

Verdict: Is tRPC Worth It?

If you live inside a TypeScript monorepo and want the fastest possible iteration loop between a typed backend and a typed frontend, tRPC is still the answer in 2026 — and v11's SSE, RSC and TanStack Query work make it more capable than ever. If you're shipping a Next.js app where a few mutations and a public REST surface are the whole job, Server Actions plus a thin route handler will probably get you there with less ceremony. We score it 82/100: outstanding DX, real ecosystem pressure, and an open-source license that means trying it costs nothing.

Frequently Asked Questions

Is tRPC free?

Yes — tRPC is fully free and open source under the MIT license. There is no paid plan, no SaaS, and no commercial tier. The maintainers accept donations via GitHub Sponsors and Open Collective.

What platforms does tRPC support?

Servers: Next.js (Pages and App Router), Express, Fastify, AWS Lambda, standalone HTTP, and any Fetch-based runtime including Bun, Cloudflare Workers, Vercel Edge, Astro, Remix and SolidStart. Clients: React (web and React Native), Vue, vanilla TS, and any framework that can import a TypeScript type.

How does tRPC compare to GraphQL?

tRPC drops the schema language and resolver layer in favour of pure TypeScript inference, which makes it dramatically faster to ship in a TS monorepo. GraphQL still wins for polyglot consumers and public APIs that need an introspectable, published schema.

Is tRPC dead now that Next.js Server Actions exist?

No — but its niche is narrower. Server Actions cover same-app mutations with zero dependencies. tRPC remains the better fit when you need batching, caching with React Query, multiple clients (web, mobile, separate frontends) hitting one backend, or transports like SSE subscriptions.

Is tRPC open source?

Yes — MIT-licensed and developed in the open at github.com/trpc/trpc.