SDK generator comparisons

Hey API and Voxgig, compared

If TypeScript is the only client you will ever need, the multi-language argument is not an argument. Here is the rest of it.

Published by Voxgig, which makes one of the two tools compared here. Facts checked against the first-party sources linked below. Corrections go to info@voxgig.com. The scope and method for every page in this section are published.

What Hey API is#

@hey-api/openapi-ts is an MIT-licensed OpenAPI to TypeScript generator with millions of weekly npm downloads, used by Vercel, PayPal and others. It is TypeScript only, on purpose.

Its architecture is a plugin pipeline. You choose what gets generated: types alone, or types plus an SDK, plus Zod schemas, plus TanStack Query hooks, plus whatever else the twenty or so plugins cover. Clients are available for fetch, axios, Angular, Next and Nuxt.

It is funded by sponsorship, with a Hey API Platform in beta. Pricing for the platform has not been announced, and the project says there will always be a free plan. The generator itself is free and open source.

What Hey API does that Voxgig does not#

Capabilities Hey API has that Voxgig does not, in enough detail to evaluate them.

A plugin architecture at a genuinely useful grain

Nothing else in this comparison lets you choose the output at this resolution. Generate only types for a project that already has a client. Add a fetch client for one that does not. Add Zod validators where you take untrusted input, and TanStack Query hooks where you render it. Every other tool here, Voxgig included, generates a library shaped the way the generator thinks a library should be shaped.

Generated TanStack Query hooks

This is the standout, and it is the clearest example of what specialising in one language buys you. For a React application talking to your API, generated query and mutation hooks with correct query keys per operation remove an entire hand-written layer that otherwise rots quietly every time the API changes. No multi-language generator will ever ship this, because the concept does not exist in Go, and that is exactly the point.

Zod schemas from the same description

Runtime validation and static types from one source, in the shape the TypeScript ecosystem already uses, rather than a validation approach invented by the generator. Speakeasy does this too, in its own SDKs. Hey API gives it to you as a plugin you can point anywhere.

Depth instead of breadth, chosen deliberately

One language means the output can follow that language's conventions exactly instead of the shape that survives translation into seven of them. A multi-language generator compromises somewhere by construction: Voxgig's TypeScript is written by a generator that also has to emit Go.

Side by side#

No partial ticks and no asterisks. If a tool has a feature, the table says it has it. Where a row would need a paragraph to be true, it is a paragraph somewhere else on this page instead of a row here.

Hey APIVoxgig
LicenceMITMIT
CostFree. Platform in beta, unpricedFree
Language targetsTypeScript22 bundled language targets, more from packages
Frontend integrationTanStack Query hooks, Angular, Next, Nuxt clientsNone. The SDK is framework neutral
Runtime validationZod, as a pluginNot generated. Types only
Cross-cutting behaviourPer plugin and per client18 generated features, same options in every target
MCP server, CLI, REPLNoYes
Output shapeWhatever you enable, plugin by pluginA complete SDK, features opt-in at construction

Which one to choose#

Choose Hey API when

  • TypeScript is the only client you need, now and in a year. If that is true, this is probably the right tool and the language count is not a real argument.
  • You want generated TanStack Query hooks or Zod validators. Nothing else here gives you those.
  • You want to generate types only, or a client only, and keep the rest of your data layer as it is.
  • You want an MIT dependency with a very large user base and no account.

Choose Voxgig when

  • You need more than one language. That is the whole difference and it is a big one.
  • You want retry, caching, idempotency, pagination and cost behaviour that means the same thing in Go and Python as it does in TypeScript, provable from one shared test corpus.
  • You need the CLI, MCP server, REPL or Agent Skills surfaces over your API.
  • You are the API provider shipping to customers whose language you do not get to choose.

Limits of this comparison#

  • The language-count row compares a multi-language generator with a TypeScript-only one, and should not be read as a measure of either.
  • On TypeScript output specifically, judged as TypeScript, Hey API is the more specialised tool and a React team may well be happier with it.
  • The Hey API Platform is in beta and unpriced. Hey API is the source for its eventual commercial model.

Corrections go to info@voxgig.com or an issue. A correction changes the page and moves its checked date; corrections from Hey API's own team carry the most weight.

Hey API documentation#

First-party sources for the claims on this page. Where they disagree with it, they are the authority.

The other comparisons#

  • OpenAPI GeneratorThe community generator most APIs have shipped an SDK from at least once.
  • SpeakeasyCommercial SDK generation with the widest non-SDK output in this comparison.
  • FernSDKs and a documentation site from one definition. Part of Postman since January 2026.
  • StainlessThe generator behind many of the best-known AI SDKs. Its hosted product is winding down.
  • APIMaticThe longest-running commercial generator here, and the only one that converts between description formats.
  • liblabSDK generation shaped as a release pipeline. Part of Postman since November 2025.
  • KiotaMicrosoft's client generator, built so you do not need a separate SDK per API.

All comparisons, the ground rules, and the wider field

Read the generated code#

The generator is MIT and open, and the catalog holds 600+ generated SDKs readable without installing anything.

Voxgig SDK GeneratorTalk to Voxgig

Get the Voxgig dispatch

Short notes on building SDKs, CLIs, REPLs, and MCPs for API-first teams, plus the occasional Fireside episode pick.

By signing up you agree to our Terms and Conditions.