# Speakeasy and Voxgig, compared

> Commercial SDK generation whose generator became AGPL-3.0 open source in September 2026. A generator you run from a CLI in your own CI, with Terraform providers, MCP servers and CLIs among its outputs and OpenAPI Overlays as its customization format. Since 17 September 2026 the generator is open source under AGPL-3.0, released with Google, and the license of what it generates is elected at generation time. Published by Voxgig, which makes one of the two tools. Facts checked 28 September 2026.

**Status.** On 17 September 2026 Speakeasy and Google published the Speakeasy generator as open source under AGPL-3.0, at `github.com/speakeasy-api/openapi-generation`. Google wrote that the provider behind its Gemini SDKs was acquired and abruptly announced its shutdown in May 2026, and that the open-source release now generates those SDKs. Speakeasy's own site leads with an AI control plane for enterprises; SDK generation continues as a product with a free account tier and quoted enterprise pricing.

## What it is

Speakeasy is a commercial SDK generation company. You run a single CLI binary locally or in CI, authenticated against a workspace, and it produces SDKs into repositories you own. Since 17 September 2026 the generator behind that CLI is open source under AGPL-3.0. Speakeasy describes the repository as the development home for the generator and its templates, and points end users back to the CLI for everyday generation.

The SDK targets are C#, Go, Java, PHP, Python, Ruby, TypeScript and Unity. Beside them the generator produces Terraform providers, CLI applications, Postman collections and MCP servers in TypeScript, plus documentation, code samples and test suites.

Its design position is that OpenAPI is the source of truth and there should be no second definition format. Where the spec is not shaped the way you want the SDK shaped, you write an OpenAPI Overlay. An Overlay is an OpenAPI Initiative specification for a document of targeted edits applied over another document. Generation settings live in a `gen.yaml`, the pipeline in a `workflow.yaml`, and the usual deployment is a GitHub Action that regenerates and opens a pull request when the spec changes.

The license of the generated code is an election you make before generation runs. Under the free election the output is AGPL-3.0-only, and the generator writes a LICENSE and a NOTICE covering Speakeasy-authored material into it. With a commercial license token the SDK is yours to license on your own terms, and Speakeasy's documentation says SDKs generated through its platform are MIT by default. A free account generates one SDK of up to 50 API methods, a new account gets a fourteen-day trial of the business tier, and the pricing page lists one enterprise plan, priced on request.

## Facts

- Made by: Speakeasy
- License: Generator AGPL-3.0. Output AGPL-3.0-only or commercial, by election
- Cost: Free under AGPL. Free account for one small SDK, then quoted
- Source: `github.com/speakeasy-api/openapi-generation` (https://github.com/speakeasy-api/openapi-generation)
- Notable output: Terraform providers, MCP servers, CLIs

## What Speakeasy does that Voxgig does not

### Terraform provider generation

This is the headline, and it deserves to be. If your API provisions anything, your larger customers want a Terraform provider. Hand-writing one is a specialized job most API teams have nobody for: resource and data-source schemas, plan and apply semantics, import, state upgrades, drift. Speakeasy generates one from the same description as the SDK. Voxgig does not generate a provider at all. If you need one, that alone is a complete reason to choose Speakeasy.

### OpenAPI Overlays instead of a private config format

Most tools solve the my spec does not describe the library I want problem with a proprietary config file. Speakeasy uses Overlay, which is a published OpenAPI Initiative specification. The practical difference is that your customizations are a standard document other tools can read, and they stay useful if you leave. It is the better-behaved answer to that problem, and it is useful to understand even if you never buy the product.

### An open-source generator whose output license you elect

The AGPL release changes what Speakeasy is. You can read the generator, fork it and run it from source with no account. If you change it and offer it as a service, the AGPL obliges you to publish the changes. The part to read twice is the output. Under the free election the SDK it generates is AGPL-3.0-only, with a LICENSE and NOTICE written in for Speakeasy's material. Only a commercial license token makes the SDK yours to license as you choose. For an API provider handing a library to customers, that election is the price of the product, and it is a clearer price than a seat count. Voxgig's generator is MIT and its output carries whatever license your repository does, with no election and no token in the pipeline.

### Zod validation, on by default, in the TypeScript SDKs

Their TypeScript output validates responses at runtime with Zod rather than casting the JSON and hoping. When a server returns a field the spec did not promise, or omits one it did, you get an error at the boundary instead of a missing value three frames away. Voxgig's `validate` feature checks requests, and optionally responses, against the model's own field types, but it is opt-in and emits no schema. Speakeasy's validation is on by default, typed with Zod, and costs a runtime dependency, which is the trade they have chosen to make.

### One standalone binary

The CLI ships as a single binary rather than a Node or JVM dependency chain. That makes it usable in locked-down and air-gapped build environments, where most Node-based tooling, Voxgig included, needs work first. Running the open-source generator from source is a different matter: it needs Go, Node, npm, Docker and each target's own toolchain, which is why Speakeasy points end users at the CLI.

### The public OpenAPI writing

Their documentation on OpenAPI itself, linting rules, spec hygiene, the parts of the specification that generators actually choke on, is a genuine public good, widely cited, and useful whether or not you ever pay them. It is not a product feature, but it is a common route by which teams find the tool.

## Side by side

| | Speakeasy | Voxgig |
| --- | --- | --- |
| License | Generator AGPL-3.0. Generated SDKs AGPL-3.0-only under the free election, yours under a commercial license | Generator MIT. Generated SDKs are yours |
| Cost | Free under AGPL. A free account for one SDK of up to 50 methods, then a quoted enterprise plan | Free |
| Account needed | No for AGPL output from source. Yes for the CLI and for a commercial license | No |
| Language targets | 8, including Unity | 23 language targets, 20 bundled plus Dart, Haskell and Lean from the langpack |
| Terraform provider | Yes | No |
| MCP server | Yes, in TypeScript | Yes |
| CLI and REPL over your API | A CLI. No REPL | Both |
| Customization | OpenAPI Overlays, `gen.yaml`, custom code regions | Model, templates, components, features, targets, packages, all in your repo |
| Support | Commercial, with an SLA on paid plans | Community, or a paid API Experience engagement |

## One API, two SDKs

Novu publishes an SDK made with Speakeasy from version 3.19.0 of its definition. Voxgig built one from version 3.19.2, as Novu served it on 28 September 2026, and both were run against a mock of 3.19.2 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.

- Speakeasy: [`@novu/api 3.19.1`](https://github.com/novuhq/novu-ts). The TypeScript SDK Novu publishes on npm, generated with Speakeasy from version 3.19.0 of the same definition.
- Voxgig: [`voxgig-sdk/novu-sdk`](https://github.com/voxgig-sdk/novu-sdk). Built on 29 September 2026 from version 3.19.2 of the same definition: eight targets from one run. A repository to build from, not a published package.
- The definition: Novu's SDK definition, `api.novu.co/openapi.sdk.yaml` at version 3.19.2: OpenAPI 3.0.0, 102 paths, 149 operations, MIT. Source: https://api.novu.co/openapi.sdk.yaml

### What each SDK does

| | Speakeasy | Voxgig |
| --- | --- | --- |
| Operations callable | 149 methods, generated from version 3.19.0 | 148 of 149. The workflow PATCH has no method |
| Mock scenario | 2 of 4 steps right. Load and create failed Zod validation on the mock's placeholder values, which is a limit of the mock | 4 of 4 right |
| Response validation | Zod, on every response | Not in this build. The opt-in validate feature checks payloads against the model's field types |
| Retries | Backoff from 1 to 30 seconds on 408, 409, 429 and 5xx, for up to an hour | On 408, 425, 429, 500, 502, 503 and 504, honoring Retry-After |
| Timeouts | Client-wide and per call, with none by default | 30 seconds per attempt by default |
| Pagination | Cursor arguments passed by hand. A page iterator is defined but no method uses it | Page and cursor state carried between calls in `ctrl.paging`, with no iterator |
| Idempotency keys | Generated for every request by a custom hook, and kept across its retries | Generated for every mutating call, and kept across its retries |
| Rate limits | 429 retried, honoring Retry-After | A client-side token bucket, and Retry-After honored on 429 |
| Logging | A debug logger that logs method, URL, headers and body | Request and response logging, with auth headers redacted |
| Offline test mode | None | A mock transport seeded with your data, which the generated tests run on |
| Metrics | None | Per-operation counts and timings, with no OpenTelemetry |
| Cancellation | An AbortSignal per call, combined with the timeout | A signal stops `stream()` between items. Only the timeout aborts a request in flight |
| Hooks | Before-request, error and response hooks on the HTTP client | Custom features that hook every stage of a call |
| Errors | Classes chosen per operation by status and schema, all extending NovuError | One error class per SDK, carrying the HTTP status and a `notFound` flag |

### What the code is

| | Speakeasy | Voxgig |
| --- | --- | --- |
| Package | `@novu/api` on npm | Not published. You build it from the repository |
| TypeScript package size | 9.26 MB in 3,908 files | 3.63 MB in 480 files |
| Runtime dependencies | 1: `zod` | None |
| Languages from this build | TypeScript | TypeScript, Python, PHP, Go, Ruby and Lua, plus a Go CLI and a Go MCP server |
| Shape | Namespaces by resource, such as `novu.workflows` and `novu.subscribers`, with a function per operation beside them | 59 entities. `Subscriber` lists, loads, creates, and removes subscribers, but several entities are still named after response schemas, such as `ListTopicSubscriptionsResponseDto` for a topic's subscriptions |
| Types | A type and a Zod schema per component, for requests and responses | An interface per entity, from the response schema. Create takes the response type, so a TypeScript create needs a cast |
| Tests | Not run here: the comparison used the published package | 548 generated TypeScript tests pass, as do the generated Go, Python, Ruby, Lua, and PHP suites |

The same calls in each, in TypeScript. `@novu/api 3.19.1`:

```ts
import { Novu } from '@novu/api'

const novu = new Novu({ secretKey: process.env.NOVU_SECRET_KEY })

const { result: page } = await novu.workflows.list({})
const { result: workflow } = await novu.workflows.get('onboarding')
const { result: created } = await novu.workflows.create({
  name: 'Onboarding',
  workflowId: 'onboarding',
  steps: [],
})
await novu.workflows.delete('onboarding')
```

`voxgig-sdk/novu-sdk`:

```ts
import { NovuSDK } from '@voxgig-sdk/novu-sdk'

const client = new NovuSDK({ apikey: process.env.NOVU_APIKEY })

const workflows = await client.Workflow().list()
const workflow = await client.Workflow().load({ id: 'onboarding' })
// WorkflowCreateData is the response schema, so without the cast TypeScript
// asks for id, createdAt and the other fields the server assigns.
const created = await client.Workflow().create({
  name: 'Onboarding',
  workflowId: 'onboarding',
  steps: [],
} as any)
await client.Workflow().remove({ id: 'onboarding' })
```

### What building and running both found

- Speakeasy's load and create failed on the mock because its Zod validation rejected placeholder values, such as the word `string` in a date-time field. Against the live API that validation is a strength, and the failure belongs to the mock.
- Voxgig has no method for PATCH /v2/workflows/{workflowId}. apidef models a PATCH beside a PUT as a sixth operation, and sdkgen generates five ([voxgig/sdkgen#211](https://github.com/voxgig/sdkgen/issues/211)).
- Voxgig's create types are the response schemas. Creating a workflow in TypeScript takes a cast, or an id and timestamps the server would assign ([voxgig/sdkgen#215](https://github.com/voxgig/sdkgen/issues/215)).
- Speakeasy keeps a resource together: `novu.subscribers.search`, `create`, `retrieve` and `delete`. Voxgig's `Subscriber` entity does the same for subscribers, but some entities are still named after response schemas, such as `ListTopicSubscriptionsResponseDto` ([voxgig/apidef#97](https://github.com/voxgig/apidef/issues/97)).
- Novu declares an `idempotency-key` header on its writes. sdkgen sent it as a query parameter until 4.32.0, which sends every header parameter as a header, so the Voxgig SDK, built on 4.32.1, sends it where Novu expects it.

The full scorecard, with the evidence for every row: https://github.com/voxgig-sdk/novu-sdk/blob/main/COMPARISON.md

## Choose Speakeasy when

- You need a Terraform provider. Nothing else on this page makes the decision as quickly.
- You want a vendor: a support contract, a roadmap, and somebody to escalate to at two in the morning.
- You want Zod-typed response validation in TypeScript, on by default rather than switched on per client.
- You want your spec customizations in a standards-track format rather than a vendor's config file.
- The AGPL election suits you, because the SDK stays inside your organization, or you will buy the commercial license and want to be able to read the generator you pay for.

## Choose Voxgig when

- You want the generated SDK under MIT or any license you choose, with no election at generation time and no license token in the pipeline.
- You want many languages under one free license. A per-SDK commercial license suits a large team shipping two SDKs better than a small team shipping seven, because the cost scales with the count.
- You want the Agent Skills and REPL surfaces as well as the SDK, the CLI and the MCP Server.
- You need to generate with no account and no network as a normal condition. The AGPL path allows it; the CLI authenticates each run against a workspace.

## Limits of this comparison

- The open-source release was eleven days old on the checked date, and Speakeasy's own site had not described it beyond the repository README. The README and Google's post are the sources, and Speakeasy may publish more.
- The SDK pair is one API of 149 operations, compared in TypeScript against a mock of its definition. It is evidence about those two SDKs rather than a benchmark of either generator, because nothing larger has been run.
- Speakeasy publishes its own comparison of this field, linked below. It predates the open-source release and, like this page, is published by a vendor in the field.
- What AGPL-3.0-only output means for the users of an SDK is a question for your lawyer. The election is stated as the repository describes it.

Corrections go to info@voxgig.com. A correction changes the page and moves its checked date.

## First-party sources

- [The Speakeasy site](https://www.speakeasy.com)
- [The open-source generator on GitHub](https://github.com/speakeasy-api/openapi-generation)
- [Google's post on the release](https://developers.googleblog.com/why-client-sdk-generation-belongs-in-the-open/)
- [Speakeasy pricing](https://www.speakeasy.com/pricing)
- [Speakeasy's own comparison of this field](https://www.speakeasy.com/blog/comparison-sdk-generators-openapi)
- [The OpenAPI Overlay specification](https://spec.openapis.org/overlay/latest.html)

## The other comparisons

- [All SDK generator comparisons](https://voxgig.com/sdk/comparisons): the index, the method, and the wider field.
- [OpenAPI Generator](https://voxgig.com/sdk/comparisons/openapi-generator): The community generator most APIs have shipped an SDK from at least once.
- [Fern](https://voxgig.com/sdk/comparisons/fern): SDKs and a documentation site from one definition. Part of Postman since January 2026.
- [Stainless](https://voxgig.com/sdk/comparisons/stainless): The generator behind many of the best-known AI SDKs. Its hosted product is winding down.
- [Cloudflare Forge](https://voxgig.com/sdk/comparisons/cloudflare-forge): Cloudflare's open-source generation pipeline, published on 28 September 2026.
- [APIMatic](https://voxgig.com/sdk/comparisons/apimatic): The longest-running commercial generator here, and the only one that converts between description formats.
- [liblab](https://voxgig.com/sdk/comparisons/liblab): SDK generation shaped as a release pipeline. Part of Postman since November 2025.
- [Kiota](https://voxgig.com/sdk/comparisons/kiota): Microsoft's client generator, built so you do not need a separate SDK per API.
- [Hey API](https://voxgig.com/sdk/comparisons/hey-api): The TypeScript ecosystem's generator, with a Python generator in early development.
- [Voxgig SDK Generator](https://voxgig.com/sdk)