Live · 7 languages · generate on your infra

Client SDKs from
your OpenAPI spec
in minutes, not months

Upload or paste your spec, download a typed SDK ZIP, and integrate on your servers — no ferrumSDK runtime required.

Hobby: 1 free generation to try. Pro ($99/mo): 100 generations/month across all 7 languages.

Try one free — no card Pro $99 · 100 gens/mo
TS TypeScript Py Python Go Go Jv Java C# .NET Ph PHP Rb Ruby
Also generates: MCP Server (TypeScript)
client.ts · generated 
import { PetstoreClient } from 'petstore-sdk';

const client = new PetstoreClient({
  apiKey: process.env.PETSTORE_API_KEY,
});

// One typed method per operation
const pets  = await client.findPetsByStatus({ status: 'available' });
const order = await client.placeOrder({ petId: 1, quantity: 2 });

Workflow

Ship an SDK in three steps

No config files. No YAML schemas. Just your spec.

01

Paste or upload your spec

Drop in JSON or YAML, fetch from a URL, or upload a file. OpenAPI 3.0 and 3.1.

02

Pick your language

TypeScript, Python, Go, Java, C# / .NET, PHP, or Ruby — idiomatic for each ecosystem.

03

Download & ship

Unzip, wire auth, run against your API. You own the code — npm, PyPI, Maven, or private.

Your spec in, a typed client out

ferrumSDK reads OpenAPI 3.0 and 3.1, in JSON or YAML, and writes the client you would write by hand: one method per operation, one type per schema, and auth taken from your security schemes.

openapi.yamlyour spec
paths:
  /pets/{id}:
    get:
      operationId: getPet
      parameters:
        - name: id
          in: path
          required: true
          schema: { type: integer }
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Pet"
components:
  schemas:
    Pet:
      required: [id, name]
      properties:
        id: { type: integer }
        name: { type: string }
        tag: { type: string }
  securitySchemes:
    ApiKeyAuth: { type: apiKey, in: header, name: X-API-Key }
TypeScript SDKgenerated
// src/client.ts
export class PetStoreClient {
  async getPet(id: number, options?: RequestOptions): Promise<Pet>
}

// src/types.ts
export interface Pet {
  id: number;
  name: string;
  tag?: string;
}

// your code
const client = new PetStoreClient({
  apiKey: process.env.PET_STORE_API_KEY,
});
const pet = await client.getPet(42);

operationId becomes the method integer becomes number $ref becomes a named type fields outside required become optional the security scheme becomes a client option

Parameters
Path, query, header and cookie, arrays included.
One document
External $ref URLs are rejected, never half-generated.
Swagger 2.0
Rejected with a message telling you how to upgrade.

Seven languages from one spec

TypeScript, Python, Go, Java, C# / .NET, PHP or Ruby. Each package follows its ecosystem’s layout and ships with its manifest, so it publishes where your users already install from.

One run, one language
Generate Go, download it, then run Java from the same spec.
No runtime
The package depends on its own language’s standard tooling, not on us.
TypeScript packagepet-store-sdk.zip
  • package.json manifest
  • tsconfig.json
  • README.md quickstart and method table
  • src/
  • client.ts one method per operation
  • types.ts one type per schema
  • http.ts retries, backoff, auth
  • errors.ts typed errors
  • pagination.ts
  • index.ts

Publish tonpm

Python packagepet-store-sdk.zip
  • pyproject.toml manifest
  • README.md quickstart and method table
  • src/pet_store/
  • client.py one method per operation
  • types.py one type per schema
  • http.py retries, backoff, auth
  • errors.py typed errors
  • pagination.py
  • __init__.py

Publish toPyPI

Go packagepet-store-sdk.zip
  • go.mod manifest
  • README.md quickstart and method table
  • client.go one method per operation
  • types.go one type per schema
  • http.go retries, backoff, auth
  • errors.go typed errors

Publish toGo modules

Java packagepet-store-sdk.zip
  • pom.xml manifest
  • src/main/java/petstore/
  • ApiClient.java one method per operation
  • Models.java one type per schema
  • HttpClient.java retries, backoff, auth
  • ApiException.java typed errors
  • Page.java

Publish toMaven

C# / .NET packagepet-store-sdk.zip
  • PetStore.csproj manifest
  • src/
  • Client.cs one method per operation
  • Models.cs one type per schema
  • HttpClientBase.cs retries, backoff, auth
  • Errors.cs typed errors
  • Pagination.cs

Publish toNuGet

PHP packagepet-store-sdk.zip
  • composer.json manifest
  • src/
  • Client.php one method per operation
  • Models.php one type per schema
  • HttpClient.php retries, backoff, auth
  • ClientConfig.php
  • ApiException.php typed errors
  • Page.php

Publish toPackagist

Ruby packagepet-store-sdk.zip
  • pet_store.gemspec manifest
  • Gemfile
  • lib/pet_store.rb
  • lib/pet_store/
  • client.rb one method per operation
  • types.rb one type per schema
  • http.rb retries, backoff, auth
  • errors.rb typed errors
  • pagination.rb
  • version.rb

Publish toRubyGems

Checked against a mock server before you download

With Pro Verify, each SDK is compiled in Docker, then every operation is called against a Prism mock server built from your spec.

What fails a run
Any exception, and any 4xx or 5xx response.
Restarts
A verification job resumes after a restart, on any worker node.
Honest results
Missing infrastructure is reported as skipped or failed, never as passed.
Verify, TypeScriptPet Store example
  1. dockernpm ci, tsc --noEmitcompiled
  2. prismmock from openapi.yamllistening
  3. GET/pets200
  4. GET/pets/{id}200
  5. POST/pets201
  6. DELETE/pets/{id}204
  7. 4 of 4 operations passed against the mock

An illustrative run. Verification proves the package compiles and matches your spec; it cannot test behavior the spec does not describe.

Retries and typed errors, already written

Every client retries 429 and 5xx responses with exponential backoff and jitter: three retries by default, starting at 500 ms and doubling. Only GET, HEAD, OPTIONS, PUT and DELETE are retried. POST and PATCH never are, so a create call never runs twice behind your back.

One GET, default settingsdrawn to scale
Status Throws (TypeScript)
400 APIBadRequestError
401 APIUnauthorizedError
403 APIForbiddenError
404 APINotFoundError
409 APIConflictError
422 APIUnprocessableEntityError
429 APIRateLimitError
500 APIInternalServerError

Each error carries the status code and the parsed response body. Statuses in blue are retried on GET, HEAD, OPTIONS, PUT and DELETE before the error is thrown.

An MCP server, so agents can call your API

On Pro Verify, a TypeScript build can include an MCP server: one tool per endpoint, wrapping the SDK it ships beside, over stdio. Point Claude or Cursor at it and your API becomes a set of tools.

Claude, Cursor

Any MCP client calls a tool by name.

mcp/, generated

One tool per endpoint, calling the SDK.

  • listPets
  • getPet
  • createPet

Your API

Auth comes from environment variables, as in the SDK.

Pet Store example; tool names follow your endpoints.

  • Compiled and smoke-run in a resource-limited container with networking off
  • Project mounted read-only while it runs
  • Two runtime dependencies: @modelcontextprotocol/sdk and zod
  • npm lifecycle scripts disabled

Pricing

Try once free. Ship with Pro.

Download SDKs and run them on your infrastructure. Pay when you need a real monthly budget.

Hobby

$0

1 SDK generation to try. Prove your OpenAPI spec works — free forever.

Start free
Most teams

Pro

$99/mo

100 generations/month · all 7 languages · instant ZIP. Replace weeks of hand-written clients.

See Pro details

Pro Verify

$199/mo

Same 100 gens/month, plus Docker compile checks, Prism mocks, and MCP server generation.

Validation & MCP

Features

Built to integrate, not to demo

Deterministic templates, idiomatic per language — finish on your own CI.

Zero lock-in

You own every file. Standard packages — npm, PyPI, Maven, or any registry. No runtime dependency on us.

One method per operation

Every operationId becomes a typed method, with its path, query, header and cookie parameters in the signature.

Auth auto-detected

Reads your OpenAPI security schemes. API keys (header, query or cookie) and Bearer tokens are wired automatically.

Ready to publish

Includes package.json, pom.xml, and language manifests — ready for any registry.

JSON & YAML

Paste, upload, or fetch from a URL. Auto-detects format. Public or internal specs.

Runs in the background

Submit your spec, close the tab, come back when it's done. Live build log if you want.

MCP Server Generation

Featured

On Pro Verify, TypeScript builds can include an MCP server so agents (Claude Desktop, Cursor, Copilot) call your API as tools.

Migrating from Stainless?

Your OpenAPI spec is all you need

If you already have an OpenAPI spec, get typed, production-quality clients — self-serve, in under a minute. No sales call.

✓

No config file required

We read your OpenAPI spec directly — no .stainless.yml.

✓

Retries and typed errors built in

429 and 5xx retried with backoff on idempotent methods; a typed error for every status.

✓

Self-serve free tier

No waitlist. Sign in and generate your first SDK now.

✓

7 languages, one spec

Regenerate the same spec per language; Pro includes 100 runs/month.

Try it with your spec Free tier · No credit card · Your spec stays private

Try your spec free today

One free generation — download and test on your servers. Need more? Pro is $99/mo for 100 SDKs.

Open SDK Builder Get Pro — $99/mo

7 languages · You own the code · No lock-in