Will it work in a browser?

On the fetch engine, yes. No Node built-ins, no dependencies, and it runs in browsers, Deno, Bun and edge runtimes as well as Node. The package declares Node 20 as its floor.

Yes, as a per-language setting. It gives your users interceptors and a familiar error shape, and adds axios to anything that bundles your SDK for the browser.

Does it ship a CLI as well?

If you turn one on. It is a project-level setting, off by default. Switch it on and the generator emits a command-line interface beside the library, one kebab-case subcommand per operation, sharing the client’s auth, retries and base URL. users.list() becomes acme users list.

What sets the package version?

Your spec does. info.version is propagated into the generated manifests on every build, so the version on the registry and the version in your OpenAPI document agree. A version edited inside a generated package.json or pyproject.toml is overwritten on the next build.

What happens when the spec changes?

The client is regenerated and rescored. Which changes break your users is worth knowing before you publish: a new required parameter and a renamed operationId are both breaking, because the method signature and the method name come straight from the document.

Yes. It is published to the registry under your account and your package name, and you can read the whole thing before it goes out. Nothing in it phones home unless a consumer turns error reporting on.

Does it cost anything to try?

The free tier covers 50 endpoints and one SDK language, with a custom domain and GitHub sync included. Paid tiers start at $49 a month and bundle more languages.

OpenAPI to TypeScript SDK generator

The client they actually get

What your users write once the TypeScript package is installed.

Two call-site shapes come out of the same spec. class-namespaced is the default: a client object whose operations are grouped by resource, which is the surface every widely used SDK ships and the one your own reference docs already assume. functions is the override: no client object, one configure call, and each operation called directly. It is a single setting, per language, and nothing else about the client changes with it.

Types come from your schemas either way, so a renamed field shows up as a compile error in your users’ editors. Free functions tree-shake, which is the main reason a bundler-minded team picks them.

Scoped or unscoped, published under your own account. npm does not allow renaming and will not republish a deleted version, so the first release claims the name for good.

The TypeScript guide, in full

import { Acme } from "@acme/api";

const acme = new Acme({
  baseUrl: "https://api.acme.com/v1",
  auth: { bearer: process.env.ACME_TOKEN },
});

// A paginated operation IS an async generator. The loop pulls the next page,
// and nothing is prefetched.
for await (const user of acme.users.list({ limit: 100 })) {
  console.log(user.id);
}

const invoice = await acme.invoices.create({
  customerId: "cus_123",
  amountCents: 4900,
});

import { configureClient, listUsers, createInvoice } from "@acme/api";

configureClient({
  baseUrl: "https://api.acme.com/v1",
  auth: { bearer: process.env.ACME_TOKEN },
});

for await (const user of listUsers({ limit: 100 })) {
  console.log(user.id);
}

const invoice = await createInvoice({ customerId: "cus_123", amountCents: 4900 });

The package at a glance

What a developer checks before adding the TypeScript package to a project.

Runs on: Node 20+, browsers, Deno, Bun and edge runtimes
Transport: Fetch API by default, axios as an option
Runtime dependencies: None on the fetch engine
Models: TypeScript types generated from your schemas
Pagination: AsyncGenerator, consumed with for await
Ships to: npm, scoped or unscoped

When a call fails

Each common status has its own subclass of SdkHttpError, so instanceof narrows the type and the editor knows which fields exist. A response your spec declares an error model for arrives decoded on err.data.

import { SdkHttpError, SdkRateLimitError } from "@acme/api";

try {
  await acme.invoices.create({ customerId: "cus_123", amountCents: 4900 });
} catch (err) {
  if (err instanceof SdkRateLimitError) {
    // 429: the client already retried with backoff. Queue it for later.
  } else if (err instanceof SdkHttpError) {
    console.error(err.statusCode, err.requestId);
  } else {
    throw err;
  }
}

What you decide for TypeScript

Set project-wide, or per language when TypeScript wants something the others do not. Defaults are the shape TypeScript SDKs actually ship.

Client style
class-namespaced (default), class, namespaced, functions
A client object whose operations are grouped by resource is the default, because it is the surface every widely used SDK ships and the one your reference docs already assume. Free functions are the override, and they tree-shake.
HTTP engine
fetch (default), axios
fetch keeps the package dependency-free on Node 20+, browsers, Deno, Bun and edge runtimes. axios buys interceptors at the cost of a dependency in your users’ bundles.
Argument style
object (default), positional
An options object survives a new optional parameter. Positional arguments break on one.

Method naming and namespacing work the same in every language: operations are grouped by your spec’s tags or by path, and the namespace word is dropped from the method name unless you ask to keep the operationId whole.

The npm name is permanent

npm has no rename, and it refuses to republish a version you deleted. A scoped name (@acme/api) is namespaced to your organisation, cannot be squatted, and reads unambiguously beside your other packages. Settle it before the first publish.

npm package name

@acme/api

Not possible: Rename the package
Not possible: Republish a deleted version
Still possible: Deprecate a version with a message

The same in every generated client

The parts nobody wants to hand-write, and the parts a hand-written client usually skips.

Retries with exponential backoff and jitter, on the statuses that mean "try again", with a per-attempt timeout.
Idempotency keys on the methods that need them, so a retried write does not become two.
Auth wired in from your spec’s security scheme, read from wherever your users keep secrets.
Typed errors split by cause: a failed constraint, an HTTP status, a network failure and a timeout are four different things.
Pagination that follows whichever contract your spec declares, cursor, offset, page number or next URL, without prefetching the collection.
Server-sent events as a native stream, for the operations that stream.
Error reporting to Octri’s monitoring, pre-wired and switched off until a consumer opts in.

How SDK Studio shapes a client

Point it at your spec
Upload an OpenAPI or Swagger document, paste a URL, or connect the repository it lives in so a merge to main updates it.
Read the audit
The spec is scored out of 10 on what a generator can do with it, with every missing schema and colliding operationId named. 8 of the fourteen rules carry a button that writes the fix.
Shape the client
Client style, argument style, namespacing, auth, retries and pagination, set once for the project and overridden per language or per endpoint.
Generate and read it
The package is generated, compiled and handed to you as source you can read before anyone installs it.
Publish, then keep publishing
Release to the registry under your own account. Every later spec change regenerates the client, and the version number comes from your own document.