JSON to TypeScript Converter

What this tool does

Generates TypeScript interfaces (or type aliases) from any valid JSON input. It walks the entire JSON tree, infers the type of every field, and produces a set of named interfaces that you can paste straight into your codebase. Designed for the common case: you've got an API response, an example payload, or a config file, and you want types that match.

What it handles well

• Nested objects — each becomes its own named interface with PascalCase naming derived from the key. user.address becomes interface Address.
• Arrays of objects — merged into one shape so the output is reusable. users: User[] instead of inlined tuples.
• Arrays of mixed primitives — become union types. (string | number)[].
• Null values — preserved as null, or treated as optional fields if you enable the toggle.
• Empty arrays — typed as unknown[] because the actual type can't be inferred from no samples.
• Reserved keys — keys that aren't valid TypeScript identifiers are auto-quoted.

Toolbar options

• Root name — the name of the top-level interface. Default is Root; use something meaningful like UserResponse or WebhookPayload.
• Use type — outputs type Foo = {...} instead of interface Foo {...}. Use this if you intend to add unions or intersections later.
• Export — prefixes every type with export. On by default.
• All optional — marks every field with ?. Useful when your JSON is a single sample and other responses may omit fields.
• Null = optional — converts null values to optional any instead of null. Use when your JSON is "field unknown" rather than "field intentionally null."
• Readonly — prefixes every field with readonly. Useful for immutable response types in Redux/Zustand stores.

What it doesn't do (yet)

• Doesn't infer enum types from string values — if a field is always one of "pending" | "active" | "closed", that's a manual edit (or paste multiple samples and the union will appear automatically).
• Doesn't generate Zod or Yup schemas — those are validation libraries with different concerns. Use Zod's z.input<typeof MySchema> in the opposite direction.
• Doesn't handle JSON Schema or OpenAPI — this converts from JSON instances, not from formal schemas. For those, use quicktype CLI.

When you'd actually use this

The typical workflow: you get an API response from a third-party (Stripe, GitHub, your own backend), you want to type it in your client code, and you don't want to hand-write 40 nested interfaces. Paste the JSON, get the types, paste them into a .ts file, rename the root, and ship.

It's also useful for working with config files, webhook payloads, scraped data, and Mongo documents — anywhere you need quick type safety from sample data. For long-term schema management, consider deriving types from a single source of truth (Zod schema, OpenAPI spec, GraphQL types) instead.

A few caveats

The generated types match what your sample JSON contains, not what the API actually returns. If a field is sometimes a number and sometimes a string across responses, you need to paste both samples for the converter to produce the union. If a field is sometimes missing entirely, enable "All optional" or paste a sample where it's absent.

For mission-critical typing — payment APIs, auth flows, anything where a wrong type costs money — consider deriving types from the official OpenAPI spec or from a validation library like Zod. This tool is for the 80% case where you need types right now and don't have a spec to lean on.