# OpenAPI Generator and Voxgig, compared

> The community generator most APIs have shipped an SDK from at least once. Apache 2.0, community governed, and broader than everything else here put together: 40+ client languages, 20+ server frameworks, plus docs, Postman collections and Protobuf. Breadth is the whole point, and the cost of it. Published by Voxgig, which makes one of the two tools. Facts checked 28 September 2026.

## What it is

OpenAPI Generator is a community fork of Swagger Codegen, made in 2018 when most of the maintainer group left the original project. It is Apache 2.0, governed by a core team with a technical committee per language, and published to Maven Central on a regular release cadence.

Calling it a generator undersells it. It is a framework hosting around a hundred generators: client libraries in more than 40 languages, server stubs for more than 20 frameworks, plus documentation, Postman collections, Protobuf schemas, GraphQL, JMeter and k6 scripts, and build configuration. Each generator is a Java class plus a tree of Mustache templates, and each has its own maintainers and its own maturity.

You configure it with command-line options, a config file, and template overrides: copy the templates out, edit them, point the CLI at your directory. It runs on the JVM, or from a Docker image, or through Maven, Gradle and npm wrappers.

The scale shows in the issue tracker. As of 28 September 2026 the repository showed over five thousand open issues and several hundred open pull requests. That number describes a hundred generators of different ages and different levels of maintenance sharing one tracker, rather than the health of any one of them. The practical consequence is that experience varies by which generator a project lands on.

## Facts

- Made by: The OpenAPITools community
- License: Apache 2.0
- Source: `github.com/OpenAPITools/openapi-generator` (https://github.com/OpenAPITools/openapi-generator)
- Cost: Free
- Runs on: JVM, or Docker

## What OpenAPI Generator does that Voxgig does not

### Breadth nothing else is close to

If you need Elixir, Perl, Rust, Scala, Erlang, PowerShell, Ada or Apex, this is often the only tool that has a generator for it. Voxgig has 23 language targets against a list roughly four times longer. Where the deciding question is whether a target exists at all, OpenAPI Generator is the widest net available.

### Server stubs, which nobody else here generates

Spring, FastAPI, Gin, Laravel, ASP.NET, Express, and about fifteen more. Generating the server skeleton from the same description as the client suits design-first API work. Voxgig generates no server-side output at all, so a team that needs a stub has no decision left to make here.

### Mustache overrides: crude, total, and yours

Extract the templates for your generator, edit them, and pass `-t ./templates`. There is no supported extension model to work within and no upgrade story for what you change, but there is also nothing you cannot change. Long-lived template forks are common, which suggests the mechanism's simplicity offsets the absence of an upgrade path for many teams.

### Nobody can buy it and switch it off

Apache 2.0, a technical committee, artifacts in Maven Central for every release since 2018. Three of the tools compared here changed owner in the ten months to May 2026, and one stopped taking new projects the day it was announced. A community-governed Apache 2.0 project with published artifacts cannot be withdrawn the same way, which is the relevant property for procurement and for long-lived builds.

### It runs in an air-gapped build with no account

A jar, or a Docker image. No sign-in, no telemetry to switch off, no seat count, and no network call at generation time, which is what a regulated or disconnected build environment needs. Voxgig, Kiota and Hey API have the same property, and since September 2026 so does the AGPL path of Speakeasy's generator. Fern's local generation checks in with a Fern API key, and every SDK language in Cloudflare Forge, TypeScript included, runs a Fern generator in Docker; APIMatic, liblab and Stainless generate on their own services.

## Side by side

| | OpenAPI Generator | Voxgig |
| --- | --- | --- |
| License | Apache 2.0 | MIT |
| Account needed | No | No |
| Language targets | 40+ client generators, 20+ server frameworks | 23 language targets, 20 bundled plus Dart, Haskell and Lean from the langpack |
| Non-SDK output | Server stubs, docs, Postman, Protobuf, GraphQL, build config | CLI, MCP Server, Agent Skills, REPL, Semantic Model, and documentation editions through docgen |
| Cross-cutting behavior | Per generator, and uneven. Some have retry, most do not | 20 features, same options and behavior in every target |
| Customization | Mustache template overrides, then a Java fork | Model, templates, components, features, targets, packages |
| Runtime | JVM or Docker | Node |
| Regenerating over your edits | Overwrite | Three-way diff-merge, plus a `doctor` command |
| Behind it | A large volunteer community and a technical committee | One small company, trading since 2018 |

## One API, two SDKs

Lob publishes an SDK made with OpenAPI Generator from a version of its definition years older than today's. Voxgig built one from the current version, and both were run against a mock of the current version on the same four steps: list, load, create, and remove. The version gap explains Lob's lower operation count, so read that row as a measure of the input rather than of either generator. 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.

- OpenAPI Generator: [`@lob/lob-typescript-sdk 1.4.2`](https://github.com/lob/lob-typescript-sdk). The TypeScript SDK Lob publishes on npm, generated with OpenAPI Generator 5.3.0 from an older version of the same definition.
- Voxgig: [`voxgig-sdk/lob-sdk`](https://github.com/voxgig-sdk/lob-sdk). Built on 29 September 2026 from the current version of the same definition: eight targets from one run. A repository to build from, not a published package.
- The definition: Lob's own OpenAPI definition, `dist/lob-api-bundled.yml` in `lob/lob-openapi` at commit `ff3a7f5`: OpenAPI 3.0.3, 58 paths, 105 operations, MIT. Source: https://github.com/lob/lob-openapi

### What each SDK does

| | OpenAPI Generator | Voxgig |
| --- | --- | --- |
| Operations callable | 70 methods, from a years-older version of the definition | 105 of 105 |
| Mock scenario on addresses | 4 of 4 steps right | 4 of 4 right, with the key sent as Lob documents it: the username, with a blank password |
| Retries | None | On 408, 425, 429, 500, 502, 503 and 504, honoring Retry-After |
| Timeouts | No SDK option. Axios's own timeout passes through | 30 seconds per attempt by default |
| Pagination | Page tokens on list results, and you call list again yourself | Page and cursor state carried between calls in `ctrl.paging`, with no iterator |
| Idempotency keys | An optional argument on some create methods, which you supply | Generated for every mutating call, and kept across its retries |
| Rate limits | None | A client-side token bucket, and Retry-After honored on 429 |
| Logging | None | 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 | No SDK option. An axios signal passes through | A signal stops `stream()` between items. Only the timeout aborts a request in flight |
| Hooks | Pass your own axios instance, with its interceptors | Custom features that hook every stage of a call |
| Errors | The raw AxiosError, rethrown with Lob's message copied in | One error class per SDK, carrying the HTTP status and a `notFound` flag |

### What the code is

| | OpenAPI Generator | Voxgig |
| --- | --- | --- |
| Package | `@lob/lob-typescript-sdk` on npm | Not published. You build it from the repository |
| TypeScript package size | 3.54 MB in 245 files | 2.70 MB in 376 files |
| Runtime dependencies | 2: `axios` and `tslib` | None |
| Languages from this build | TypeScript | TypeScript, Python, PHP, Go, Ruby and Lua, plus a Go CLI and a Go MCP server |
| Shape | A class per API tag, such as `AddressesApi`, with a method per operation | 33 entities, such as `Address`, each with the list, load, create, update and remove operations the API has |
| Types | A model class per schema, for requests and responses | An interface per entity, from the response schema, with nested objects typed `any` |
| Tests | Not run here: the comparison used the published package | 455 generated TypeScript tests pass, as do the generated Go, Python, Ruby, Lua, and PHP suites |

The same calls in each, in TypeScript. `@lob/lob-typescript-sdk 1.4.2`:

```ts
import { AddressEditable, AddressesApi, Configuration } from '@lob/lob-typescript-sdk'

const addresses = new AddressesApi(new Configuration({ username: process.env.LOB_API_KEY }))

const page = await addresses.list(10)
const address = await addresses.get('adr_123')
const created = await addresses.create(new AddressEditable({
  name: 'Thing T. Thing',
  address_line1: '1313 CEMETERY LN',
  address_city: 'WESTFIELD',
  address_state: 'NJ',
  address_zip: '07090',
}))
await addresses.delete('adr_123')
```

`voxgig-sdk/lob-sdk`:

```ts
import { LobSDK } from '@voxgig-sdk/lob-sdk'

const client = new LobSDK({ apikey: process.env.LOB_APIKEY, secret: process.env.LOB_SECRET })

const addresses = await client.Address().list()
const address = await client.Address().load({ id: 'adr_123' })
const created = await client.Address().create({
  name: 'Thing T. Thing',
  address_line1: '1313 CEMETERY LN',
  address_city: 'WESTFIELD',
  address_state: 'NJ',
  address_zip: '07090',
})
await client.Address().remove({ id: 'adr_123' })
```

### What building and running both found

- Lob's SDK has 70 methods because Lob generated it from a definition years older than the one used here. The gap is in its input, not in OpenAPI Generator.
- sdkgen sent Basic auth only when both a key and a secret were set until 4.31.0, so a Lob user who followed Lob's documentation sent no Authorization header. The Voxgig SDK is built on 4.32.1 and sends the key as Lob documents it, with a blank password.
- apidef read Lob's address list at `body` until 8.18.0, although Lob puts it at `body.data` inside an allOf, so list returned nothing and the `Address` type carried the page's `count` and `next_url`. On 8.22.0 the list and the type both read the address.
- Lob declares `Idempotency-Key` on nine creates. sdkgen sent it in the request body until 4.32.0, which sends every header parameter as a header, and Voxgig's idempotency feature can also generate the key for you.
- OpenAPI Generator generates a model class per schema, for requests and responses. Voxgig types each entity's top-level fields from the response schema and leaves nested objects as `any` ([voxgig/sdkgen#220](https://github.com/voxgig/sdkgen/issues/220)).

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

## Choose OpenAPI Generator when

- The language or framework you need is not among Voxgig's 23 targets. OpenAPI Generator's list is roughly four times longer.
- You need a server stub. Voxgig generates clients and consumer surfaces only, nothing server-side.
- You already have a template fork that works. Migrating a working fork costs more than it returns, and a generator you have already bent to your shape is worth more than a better one you have not.
- Procurement wants an Apache 2.0 artifact with multi-vendor governance and a decade of releases behind it.
- Your API is small and a typed wrapper is all anyone asked for. Do not buy a feature model you will not switch on.

## Choose Voxgig when

- You want retries, idempotency keys, pagination, caching and tracing generated with the same behavior in every language, instead of hand-written once per language on top of whatever the generator gave you.
- You want a CLI, an MCP Server and a REPL that cannot drift from the SDK, because all of them come from one model on one run.
- You want your customization to survive upgrades. Voxgig's extension points are declared in the model and packaged, so a resync refreshes stock content without touching yours, and `doctor` reports the drift either way.
- You want generated code with no runtime dependency on the generator and nothing to install at call time.

## Limits of this comparison

- The standard criticism, that the output is not idiomatic, is too broad to be fair. It is a hundred generators. The Go and Python clients are better than the reputation suggests; some of the long tail is worse. Judge the generator for your language, not the project.
- The SDK pair covers one of its generators, the TypeScript one, through the SDK Lob publishes, run against a mock of Lob's definition. The other generators' output is described from publicly readable generated code, not from a benchmark.
- The open-issue count is a poor health proxy for a project this size. Read it as a description of scale, not as a verdict.
- The SDK pair is one API, compared in TypeScript against a mock of its definition rather than the live service. Lob's SDK comes from a definition years older than the one used here, so its operation count measures its input, not the generator.

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

## First-party sources

- [The project site](https://openapi-generator.tech)
- [The generator list](https://openapi-generator.tech/docs/generators)
- [Source on GitHub](https://github.com/OpenAPITools/openapi-generator)

## The other comparisons

- [All SDK generator comparisons](https://voxgig.com/sdk/comparisons): the index, the method, and the wider field.
- [Speakeasy](https://voxgig.com/sdk/comparisons/speakeasy): Commercial SDK generation whose generator became AGPL-3.0 open source in September 2026.
- [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)