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. Every page in this section follows the same scope and method.

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, OpenCode, PayPal, AWS, and Autodesk among others. TypeScript is the language it ships for. A second generator, @hey-api/openapi-python, for Python SDKs and Pydantic models, was at version 0.0.24 on the checked date; its README calls it initial development and the site lists Python as coming soon.

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 specializing 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 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. Voxgig's validate feature checks payloads against the model's field types without emitting a schema, so there is nothing to hand to a form library or a route handler.

Depth instead of breadth, chosen deliberately

One generator per language means the output can follow that language's conventions exactly, instead of the shape that survives translation into seven of them. That is why the Python generator is a separate codebase rather than a new target inside the TypeScript one. 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
LicenseMITMIT
CostFree. Platform in beta, unpricedFree
Language targetsTypeScript. Python in initial development23 language targets, 20 bundled plus Dart, Haskell and Lean from the langpack
Frontend integrationTanStack Query hooks, Angular, Next, Nuxt clientsNone. The SDK is framework neutral
Runtime validationZod schemas, as a pluginThe opt-in validate feature, against the model's own field types, with no schema library
Cross-cutting behaviorPer plugin and per client20 generated features, same options in every target
CLI, MCP Server, REPLNoYes
Output shapeWhatever you enable, plugin by pluginA complete SDK, features opt-in at construction

One API, two SDKs#

Neon publishes an SDK made with Hey API. Voxgig built one from the same definition, and both were run against a mock of that definition on the same four steps: list, load, create, and remove. Voxgig's features are in the build and stay off until a client switches them on; the rows describe them switched on. Last measured 29 September 2026.

Hey API

@neon/sdk 6.1.2

The TypeScript SDK Neon publishes on npm: a client generated with Hey API's openapi-ts 0.98.2, inside a hand-written wrapper.

Voxgig

voxgig-sdk/neon-sdk

Built on 29 September 2026 from the same definition: eight targets from one run. A repository to build from, not a published package.

The definition: Neon's published definition, neon.com/api_spec/release/v2.json: OpenAPI 3.0.3, 122 paths, 179 operations, Apache-2.0 by way of Neon's SDK repository. Its source.

What each SDK does

Hey APIVoxgig
Operations callable177 methods178 of 179. The project PATCH, which is Neon's real update, has no method
Mock scenario on projects4 of 4 steps right4 of 4 right
RetriesTwo retries on 423, 429 and 503, in the hand-written wrapperOn 408, 425, 429, 500, 502, 503 and 504, honoring Retry-After
TimeoutsClient-wide and per call, in the wrapper. Unbounded by default30 seconds per attempt by default
PaginationPages, all() and for await, in the wrapperPage and cursor state carried between calls in ctrl.paging, with no iterator
Idempotency keysNoneGenerated for every mutating call, and kept across its retries
Rate limitsRetry-After honored on 429, 423 and 503, in the wrapperA client-side token bucket, and Retry-After honored on 429
LoggingNoneRequest and response logging, with auth headers redacted
Offline test modeNone. A fetch option lets you inject your ownA mock transport seeded with your data, which the generated tests run on
MetricsNonePer-operation counts and timings, with no OpenTelemetry
CancellationAn AbortSignal per callA signal stops stream() between items. Only the timeout aborts a request in flight
HooksRequest, response and error interceptors, from the generated clientCustom features that hook every stage of a call
ErrorsTyped in the wrapper: not found, auth, rate limit, API, network, abort and timeoutOne error class per SDK, carrying the HTTP status and a notFound flag

What the code is

Hey APIVoxgig
Package@neon/sdk on npmNot published. You build it from the repository
TypeScript package size2.42 MB in 210 files4.01 MB in 544 files
Runtime dependenciesNoneNone
Languages from this buildTypeScriptTypeScript, Python, PHP, Go, Ruby and Lua, plus a Go CLI and a Go MCP server
ShapeResource namespaces, such as neon.projects, returning { data, error } or throwing, as you choose, plus the raw generated functions75 entities, such as Project, each with the list, load, create, update and remove operations the API has
TypesGenerated types per schema, and typed parameters in the wrapperAn interface per entity, from the response schema. Create takes the response type, so a TypeScript create needs a cast
TestsNot run here: the comparison used the published package653 generated TypeScript tests pass, as do the generated Go, Python, Ruby, Lua, and PHP suites

The same calls in each, in TypeScript. Both samples type-check under strict mode against the SDK they name.

@neon/sdk 6.1.2
import { createNeonClient } from '@neon/sdk'

const neon = createNeonClient({ apiKey: process.env.NEON_API_KEY!, throwOnError: true })

const projects = await neon.projects.list().all()
const project = await neon.projects.get({ projectId: 'late-frost-12345' })
const created = await neon.projects.create({ name: 'app' })
await neon.projects.delete({ projectId: 'late-frost-12345' })
voxgig-sdk/neon-sdk
import { NeonSDK } from '@voxgig-sdk/neon-sdk'

const client = new NeonSDK({ apikey: process.env.NEON_APIKEY })

const projects = await client.Project().list()
const project = await client.Project().load({ id: 'late-frost-12345' })
// ProjectCreateData is the response schema, so without the cast TypeScript
// asks for id, created_at and the other fields the server assigns. The SDK
// wraps the input in the { project } body Neon's create expects.
const created = await client.Project().create({ name: 'app' } as any)
await client.Project().remove({ id: 'late-frost-12345' })

What building and running both found

  • Neon's retries, timeouts, pagination and typed errors are in a hand-written wrapper over the Hey API client. What Hey API generated is the typed functions underneath, which the package also exports as raw.
  • apidef read Neon's project list at body until 8.19.0, although Neon puts it at body.projects beside pagination, so Voxgig's list read 0 projects.
  • Neon's writes answer the record beside other parts: a project create answers its project beside connection_uris and operations. apidef 8.22.0 reads the record through that composed response, which fixed the create and 13 more of Neon's writes (voxgig/apidef#112).
  • Voxgig maps its project update to a transfer-request PUT, and Neon's real update, PATCH /projects/{project_id}, has no method (voxgig/sdkgen#211).
  • Entities named operation, context or control collided with the SDK's own type names and broke the TypeScript build on sdkgen 4.30.2. The fix shipped in 4.30.3, so the Voxgig SDK, built on 4.32.1, has it.

The full scorecard, with the evidence for every row

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 tool to use, 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 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 behavior 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, Agent Skills or REPL 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 single-language one, and should not be read as a measure of either.
  • On TypeScript output specifically, judged as TypeScript, Hey API is the more specialized 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.
  • The SDK pair is one API, compared in TypeScript against a mock of its definition. Neon's SDK is a hand-written wrapper over a Hey API client, so its retries, pagination and typed errors belong to Neon's engineers, not to the generator.

Corrections go to info@voxgig.com or an issue on the generator repository. 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 whose generator became AGPL-3.0 open source in September 2026.
  • 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.
  • Cloudflare ForgeCloudflare's open-source generation pipeline, published on 28 September 2026.
  • 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, MCP Servers, and REPLs for API-first teams, plus the occasional Fireside episode pick.

By signing up you agree to our Terms of use.