⌘ K
openapi → typescript · types & interfaces · refs · enums · live

Generate TypeScript from OpenAPI

Pull every schema out of an OpenAPI 3 (or Swagger 2) document and emit a TypeScript interface or alias per schema. Refs, enums, required flags and primitive types are all honoured.

OpenAPI → TypeScript
Input
488 B
21 lines
Output
132 B
8 lines
Status
ready
live
Ratio
0.27×
out/in
input · openapi / swagger json
output · typescript
export interface User {
  id: number;
  email: string;
  name?: string;
  role?: "admin" | "user";
}

export type UserList = User[];
Quick Start

How generation works

Schemas at components.schemas (OpenAPI 3) or definitions (Swagger 2) are read. Each schema's shape becomes an interface (for object types) or a type alias. $ref targets are referenced by their PascalCased name; enums emit as string-literal unions.

  1. 01

    Paste the spec

    Either an OpenAPI 3 doc with components.schemas or a Swagger 2 doc with definitions.

    Parsing is strict-but-tolerant — comments and trailing commas are accepted on input where the source format historically permits them; output stays canonical.

    inputstricttolerantliveparse
    in · sourcespec · live
    { "components": { "schemas": {...} } }
    loaded · parsedtarget · ready
  2. 02

    Schemas extracted

    Each named schema becomes one exported type or interface.

    Conversion preserves type information where the target supports it (numbers stay numeric, booleans stay boolean) so the destination parser never has to re-coerce.

    extracttype-preservinglosslesslivememoised
    n schemas · optionsn types · live
    User → interface User
    options applied · liveround-trip
  3. 03

    Refs resolved

    $ref: "#/components/schemas/User" becomes the PascalCased name "User" inline.

    Re-encoding is idempotent: running output back through the same converter produces the same bytes, which keeps round-trips git-friendly.

    refsidempotentround-tripdiff-cleandeterministic
    $ref · convertedname · ready
    { user: User }
    converted · livediff-clean
  4. 04

    Copy or download

    Drop into a .d.ts file or your client SDK source.

    Copy writes via navigator.clipboard.writeText; downloads use the target’s native MIME so editors apply the right syntax highlighting on open.

    exportclipboardtarget MIMEblobclient-side
    ✓ · copiedready · done
    ✓ Copied
    shipped · ready to shipsuccess
Pro tips

Converting between formats, safely

Pick the strictest source format

Lossy formats hide bugs. Choose JSON or YAML as your source-of-truth, convert downstream as needed.

Round-trip in CI

If your converter is idempotent, your CI can verify A → B → A equals the original. Catches subtle data loss.

Numbers vs strings differ

YAML/TOML have a number type; CSV doesn’t. Quote IDs in CSV to keep leading-zero values intact.

Watch character encoding

Source format may be Latin-1 / Windows-1252; target should be UTF-8. Convert encoding before structure.

Preserve comments where you can

YAML and TOML support comments. Don’t silently drop them — they often encode intent.

Schema-aware beats blind

Use a schema to guide conversion. Field types, required-ness, and defaults survive better with structure.

Related toolsOpenAPI v2 → v3JSON to TypeScriptHAR to cURLcURL to fetch()JSON to XMLXML to JSON
Use Cases

When to generate types

SDKs, type-safe clients, contract tests.

API SDK scaffolding

Bootstrap a type-safe client from an upstream spec. Type information survives: numbers stay numeric, booleans stay boolean, strings stay strings. The destination parser doesn't have to re-coerce, which avoids the "'true' becomes "true"" bug class.

round-trip safe

Contract tests

Lock test fixtures to the canonical API schema. Run output back through the inverse converter to verify idempotent round-trips in CI. A → B → A should produce byte-identical input — if it doesn't, you've found data loss.

type-preserving

Front-end clients

Type the fetch / axios layer against the same schemas the server uses. Comments and metadata survive where the target format supports them (YAML, TOML, HCL). The tool doesn't silently drop intent-encoded annotations, which keeps your config self-documenting.

schema-aware

Migration

Move from openapi-codegen to a hand-curated subset. Pair with a schema (JSON Schema, OpenAPI, Zod, Pydantic) to catch shape drift on either side. Catch breaking changes at conversion time rather than at runtime in production.

lossless

PR review

Spot breaking schema changes by diffing generated types. Output respects target-format conventions: quoting in CSV, indent in YAML, brackets in JSON. Existing parsers don't need patches, and the result drops into legacy pipelines unchanged.

diff-clean

Documentation

Embed generated types in technical docs as the source of truth. Encoding-aware: handles UTF-8 vs UTF-16 vs Latin-1 / Windows-1252 transparently. The character-set surprise that breaks "works on my machine" doesn't apply here.

spec-grade
FAQ

Frequently asked questions

Object-shaped schemas emit as interfaces; unions, arrays and other scalars emit as type aliases.
Yes — properties missing from the required array become optional with a ?: marker.
No — only the schemas. For the operation surface use openapi-typescript or similar code generators.
Schemas using nullable: true aren't widened to T | null yet. PR welcome.
No. Type generation runs locally in your browser.
Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

Sent straight to the maintainers · no account needed
47 in queue·8 shipped this month
Request queued. Thanks!