# APIMatic and Voxgig, compared

> The longest-running commercial generator here, and the only one that converts between description formats. SDKs in seven languages, a developer portal, spec validation, and API Transformer, which converts API descriptions between more than fifteen formats. The lowest entry price of the commercial tools on this site. Published by Voxgig, which makes one of the two tools. Facts checked 28 September 2026.

## What it is

APIMatic is a commercial developer-experience platform for API providers, and one of the oldest companies in this category, trading well before the current wave of SDK generators.

It generates SDKs in seven languages: Java, Python, C# and .NET, TypeScript, PHP, Ruby and Go. Around them sits a developer portal product with an API reference, a code playground, runnable samples, guided onboarding flows they call API Recipes, and usage analytics. Since April 2026 the CLI keeps your additions to a generated SDK on a `custom` branch and reapplies them as diffs on regeneration. It also publishes to package registries from CI through the same publishing profiles the dashboard uses. An MCP server generator, in TypeScript and built on the TypeScript SDK, is in an alpha you join by asking.

There are two things it does that nobody else here does. API Transformer converts API descriptions between more than fifteen formats. The Code Sample API exposes generation as an HTTP service, so a documentation site can render a working per-endpoint sample in every supported language without running a generator in its own build.

Pricing starts lower than the rest of the commercial field, at a small monthly tier for one API and one language, rising through per-language plans to quoted business and enterprise agreements, with a trial. Current figures are on APIMatic's pricing page.

## Facts

- Made by: APIMatic
- License: Proprietary. Generated SDKs are yours
- Language targets: 7
- Distinctive: API Transformer, 15+ description formats
- Site: `apimatic.io` (https://www.apimatic.io)

## What APIMatic does that Voxgig does not

### API Transformer

Converts between OpenAPI 2 and 3, RAML, API Blueprint, WSDL, WADL, Postman Collections, HAR and more, in both directions where it makes sense. No other tool in this comparison converts between description formats, which is why APIMatic appears inside other companies' pipelines as well as competing with them. For an API described in RAML, API Transformer is the practical on-ramp to every other tool on this page, Voxgig included.

### Generation as an HTTP service

The Code Sample API means your documentation site can ask for a sample for one endpoint in one language and render it, at request time, without owning a generator or a build step. That is a different product shape from everything else here, and for a docs team that cannot take on a code-generation pipeline it is the difference between having per-language samples and not having them.

### The developer portal as the product, not the by-product

The SDK is one output of a portal that also carries the reference, the playground, the onboarding flows and the analytics that tell you which endpoints people actually get stuck on. If your problem is adoption rather than maintenance, that is a different and possibly more useful shape of answer than a better generator.

### The lowest cost of entry in the commercial field

For a small API and a single language, APIMatic's entry tier is an order of magnitude below where the newer commercial tools start. If the question is whether a paid tool is affordable at all for a side product or a small team, this is the one where the answer is most often yes.

### A specification analyser with an opinion about code generation

Their validation and linting predates most of the current linters. It is unusually specific about the things that break generation rather than the things that offend a style guide: missing operation ids, unnamed inline schemas, ambiguous discriminators. Useful diagnostics whatever you generate with afterwards.

## Side by side

| | APIMatic | Voxgig |
| --- | --- | --- |
| License | Proprietary. Generated SDKs are yours | MIT. Generated SDKs are yours |
| Cost | Lowest commercial entry tier, then per language, then quoted | Free |
| Language targets | 7 | 23 language targets, 20 bundled plus Dart, Haskell and Lean from the langpack |
| Input formats | 15+, through API Transformer | OpenAPI |
| Developer portal | Yes, a full product | No. docgen generates a static reference site you host |
| MCP server | In alpha, on request, in TypeScript | Yes |
| CLI and REPL over your API | No | Yes |
| Regenerating over your edits | A `custom` branch of diffs, reapplied on regeneration | Three-way diff-merge, plus a `doctor` command |
| Package publishing | Publishing profiles, from the dashboard or the CLI | Your repository and your CI |
| Generation runs | On their service | On your machine |

## One API, two SDKs

Maxio Advanced Billing publishes an SDK made with APIMatic. 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.

- APIMatic: [`@maxio-com/advanced-billing-sdk 10.0.0`](https://github.com/maxio-com/ab-typescript-sdk). The TypeScript SDK Maxio publishes on npm, generated with APIMatic.
- Voxgig: [`voxgig-sdk/maxio-advanced-billing-sdk`](https://github.com/voxgig-sdk/maxio-advanced-billing-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: Maxio's exported definition from developers.maxio.com: OpenAPI 3.0.0, 196 paths, 268 operations, MIT. Source: https://developers.maxio.com

### What each SDK does

| | APIMatic | Voxgig |
| --- | --- | --- |
| Operations callable | 249 of 268 | 266 of 268. Two PATCH operations have no method |
| Mock scenario on customers | 4 of 4 steps right, after a patch to its base URL to reach the mock | 3 of 4 right. Load, create, and remove return the customer, but list returns each one inside its `{ customer }` wrapper |
| Retries | Configured, but off by default | On 408, 425, 429, 500, 502, 503 and 504, honoring Retry-After |
| Timeouts | 120 seconds, client-wide | 30 seconds per attempt by default |
| Pagination | None. Page and per-page arguments by hand | Page and cursor state carried between calls in `ctrl.paging`, with no iterator |
| Idempotency keys | None | Generated for every mutating call, and kept across its retries |
| Rate limits | 429 is on the retry list, but retries are off by default | 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 | Request options on every method, wired to an abort in the shared core | A signal stops `stream()` between items. Only the timeout aborts a request in flight |
| Hooks | None, beyond overriding the axios client | Custom features that hook every stage of a call |
| Errors | 23 error classes mapped per operation, mostly for 422, and the base ApiError otherwise | One error class per SDK, carrying the HTTP status and a `notFound` flag |

### What the code is

| | APIMatic | Voxgig |
| --- | --- | --- |
| Package | `@maxio-com/advanced-billing-sdk` on npm | Not published. You build it from the repository |
| TypeScript package size | 9.41 MB in 7,205 files | 3.06 MB in 468 files |
| Runtime dependencies | 5: APIMatic's core, schema, authentication and `axios` adapter packages, 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 controller per API area, such as `CustomersController`, with a method per operation, returning an `ApiResponse` | 56 entities, such as `Customer`, each with the list, load, create, update and remove operations the API has |
| Types | A model per schema, validated at run time by APIMatic's schema package | An interface per entity, from the response schema, which here is the `{ customer }` wrapper beside the customer's own fields |
| Tests | Not run here: the comparison used the published package | 670 generated TypeScript tests pass, as do the generated Go, Python, Ruby, Lua, and PHP suites |

The same calls in each, in TypeScript. `@maxio-com/advanced-billing-sdk 10.0.0`:

```ts
import { Client, CustomersController } from '@maxio-com/advanced-billing-sdk'

const client = new Client({
  basicAuthCredentials: { username: process.env.MAXIO_API_KEY!, password: 'x' },
  site: 'acme',
})
const customers = new CustomersController(client)

const { result: page } = await customers.listCustomers({})
const { result: customer } = await customers.readCustomer(123)
const { result: created } = await customers.createCustomer({
  customer: { firstName: 'Ada', lastName: 'Lovelace', email: 'ada@example.com' },
})
await customers.deleteCustomer(123)
```

`voxgig-sdk/maxio-advanced-billing-sdk`:

```ts
import { MaxioAdvancedBillingSDK } from '@voxgig-sdk/maxio-advanced-billing-sdk'

const client = new MaxioAdvancedBillingSDK({
  apikey: process.env.MAXIO_ADVANCED_BILLING_APIKEY,
  secret: 'x',
  server: { site: 'acme' },
})

const customers = await client.Customer().list()
const customer = await client.Customer().load({ id: 123 })
const created = await client.Customer().create({
  customer: { first_name: 'Ada', last_name: 'Lovelace', email: 'ada@example.com' },
})
await client.Customer().remove({ id: 123 })
```

### What building and running both found

- APIMatic's SDK builds its base URL from an environment and a site only, so reaching the mock took a patch to `getBaseUri`. That is no limit against Maxio's own servers, but it makes testing against anything else harder.
- APIMatic's retries are configured and off by default, and its SDK has 249 methods for the definition's 268 operations.
- Voxgig's list returns each customer inside its `{ customer }` wrapper, one level above its own fields, because Maxio's lists answer an array of wrapped records and apidef unwraps a page, not each item in it ([voxgig/apidef#113](https://github.com/voxgig/apidef/issues/113)).
- Voxgig's load, create, and remove unwrap that same `{ customer }` envelope, so a listed customer and a loaded one have different shapes until [voxgig/apidef#113](https://github.com/voxgig/apidef/issues/113) is fixed.
- Voxgig has no methods for two PATCH operations on price points, because 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)).

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

## Choose APIMatic when

- Your API is described in something other than OpenAPI. Transformer alone is worth the conversation.
- You want a developer portal and SDKs from one vendor, at the lowest entry price in this comparison.
- You want per-endpoint code samples served into your own documentation as an API rather than as a build step.
- Seven languages covers you and you would rather buy than own.

## Choose Voxgig when

- You want the generator in your repository rather than a service you post a spec to.
- You need a CLI, Agent Skills or a REPL as well as the SDK, or an MCP server that is generally available rather than in alpha.
- You need more than seven languages, or the same feature behavior verifiable across all of them.
- You want to read the code that writes your code.

## Limits of this comparison

- APIMatic publishes less about generated-SDK internals than the newer vendors do, so its output is described from one published SDK, Maxio's, and the platform from product documentation. Corrections from teams running it in production are welcome.
- The SDK pair is one API, compared in TypeScript against a mock of its definition. APIMatic's SDK needed a patch to reach the mock at all, which says nothing about how it behaves against Maxio's servers.
- APIMatic's founding year could not be confirmed from a primary source.
- APIMatic's tiers and limits are more granular than a comparison table can carry. The shape is here; the numbers are on their pricing page.

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

## First-party sources

- [The APIMatic site](https://www.apimatic.io)
- [API Transformer](https://www.apimatic.io/solution/transformer)
- [APIMatic's MCP server generator](https://docs.apimatic.io/generate-mcp-servers/mcp-server-overview/)
- [APIMatic's April 2026 product notes](https://www.apimatic.io/blog/april-2026-product-highlights)
- [APIMatic pricing](https://www.apimatic.io/pricing)

## 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.
- [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.
- [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)