Make your product agent-ready.

Generate a CLI, MCP server, and SDKs from your existing API spec. Typeship keeps them up to date as your API changes.

Swagger 2.0, OpenAPI 3.0/3.1, and GraphQL supported.

Free preview · No Typeship sign-in required. Generated packages include the first 25 API operations.

Plan limits
Target

Using a coding agent? Copy this prompt to set up Typeship in the repository.

Agents need a reliable interface to your API.

Agents call APIs through structured tools. Input schemas, error contracts, and pagination determine whether a call succeeds without intervention.

A CLI, MCP server, and language SDK each become a public interface to maintain. Building them by hand means reviewing the same API change across every client.

Typeship generates, tests, and publishes each interface from one Spec, then keeps it current as the contract changes.

One API, every client surface

Give every user a native way to call your API.

Start with a CLI, add an MCP server, and publish native SDKs for TypeScript, Python, and Go. Choose only what your API needs; each stays current from the same spec.

acme — zsh
$

CLI

Ship every API operation as a command with typed flags, structured output, and predictable exit codes. Pagination, errors, and confirmations behave consistently for coding agents, developers, and scripts.

acme
$ acme accounts create --name "Operating" --currency usd
{ "id": "acct_1Kx9", "name": "Operating", "currency": "usd" }
$ acme accounts list --all | jq -r '.id'
acct_1Kx9
acct_2Ryq
…
$ acme accountz list
acme: Unknown command: accountz. Did you mean 'acme accounts'?
Run 'acme --help' for the commands.
UNKNOWN_COMMAND · exit 2 · pipe stderr or --mode agent for JSON
CLI docs

MCP server

Publish a hosted MCP server at a stable URL, with tools shaped to your API. Agents discover operations, read documentation, and execute calls through typed inputs and errors.

acme-mcp · compact tools
search_docs Find operations and guides
read_docs Read an operation's schema and safety
execute Call it with typed arguments
search_docs { query: "close an account" }
→ accounts_close · POST /accounts/{id}/close
read_docs { page: "accounts_close" }
→ destructive · execute requires confirm: true
MCP server docs

SDKs

Publish idiomatic TypeScript, Python, and Go SDKs generated from your Spec and ready to install. Authentication, pagination, retries, and typed errors are built in.

SDK · TypeScript
import { AcmeClient } from "acme";
const client = new AcmeClient({
bearerToken: process.env.ACME_TOKEN!,
});
const result = await client.accounts.list({ limit: 5 });
if (!result.ok) throw result.error; // typed by status
for await (const account of client.accounts.list()) {
// every page, one loop
}
SDK docs

Designed for successful calls

Reliable for agents. Familiar to developers.

Each generated interface follows its ecosystem's conventions, with typed inputs, errors, pagination, retries, and safety controls built in.

Errors an agent can act on

Failures come back typed, with the status and your API's own error body. Documented statuses are a union the compiler enforces in the SDK and an isError result in MCP. No bare strings to parse.

Pagination the agent controls

Every paginated operation returns one page plus hasMore. The SDK folds it into a single loop, the CLI streams every page as NDJSON with --all, and the agent decides when to stop.

Authentication for each interface

Authentication is generated from the Spec and Target configuration. CLIs store credentials locally, SDKs accept them as client options, and MCP servers enforce them at the tool boundary.

Documentation in every interface

Every generated CLI, MCP server, and SDK includes an API reference, machine-readable metadata, and agent instructions. CLI and MCP also make your connected guides searchable at runtime.

A tool surface sized to the API

Smaller APIs expose one typed tool per operation. Larger APIs switch to search_docs, read_docs, and execute, preserving full coverage without loading every operation into context.

Zero dependencies. Yours to keep.

Readable source with no runtime dependency on Typeship. Retries, backoff, Retry-After, and declared idempotency behavior are built in. You own the repository and publish the package under your name.

Stays current

The Spec changes. The pull request is already open.

Connect your Spec and choose where each generated interface belongs. Typeship watches the source, regenerates each one, and opens a pull request in every destination with the API diff, breaking changes, and required version bump.

  • Watch definitions in your product repository or at a URL
  • Preview generated changes on API pull requests
  • Review compatibility, changelogs, and versions in release pull requests
  • Merge and publish from repositories you own
How regeneration works
acme / typescript
Update acme: 2 breaking API changes#212
Open
typeship/update-typescript-sdk-a4c91e72bf→main
## 3.0.0 (2026-08-25) (2 breaking)
### Added
- `accounts.close()`: POST `/accounts/{id}/close`
### Removed (breaking)
- `accounts.archive()`: POST `/accounts/{id}/archive`
### Changed
- `accounts.list()`
- breaking `param-required`: status is now required
✓ Release readiness · 3.0.0 satisfies the required major bump

Make your API agent-ready.

Point Typeship at your API spec. Ship a CLI, an MCP server, and native SDKs without turning each one into another maintenance project.