JSON to TypeBox Schema Generator

What is JSON to TypeBox Schema Generator?

TypeBox (@sinclair/typebox) is unusual among TypeScript validation libraries: the object you build with Type.Object({...}) is a literal, standards-compliant JSON Schema at runtime AND a static TypeScript type at compile time. There is no codegen step and no separate type declaration — you write the schema once with Type.* builders and extract the type with Static<typeof Schema>. Because the output is real JSON Schema, you do not validate with a TypeBox-specific runtime; you hand the schema to any JSON Schema validator, almost always Ajv, or to Fastify, whose serializer and validator both speak JSON Schema natively. That JSON-Schema-first design is the key difference from Zod, Yup, and Valibot, which all carry their own bespoke validation runtime. TypeBox itself ships essentially zero validation logic — it is a schema *builder*. This makes it the natural choice when you already live in the JSON Schema ecosystem: Fastify route schemas, OpenAPI generation, fast-json-stringify serialization, or AJV-based form validation. This generator infers Type.String, Type.Integer (it distinguishes integers from floats), Type.Number, Type.Boolean, Type.Null, Type.Array, and nested Type.Object from your sample, and appends the Static<typeof T> type alias so you get inference immediately.

How to Use

1. Paste a representative JSON sample and click Generate; the tool emits Type.Object(...) plus a `type T = Static<typeof T>` line so you get the runtime schema and the static type in one shot
2. Install the package with `pnpm add @sinclair/typebox` and a validator if you are not on Fastify: `pnpm add ajv`
3. For Fastify, drop the generated schema straight into a route as `{ schema: { body: T } }` — Fastify uses it for both request validation and faster response serialization, no Ajv setup required
4. For standalone validation, compile once with Ajv: `const validate = ajv.compile(T)` and reuse the compiled function on the hot path — never recompile per request
5. Mark genuinely optional properties by wrapping them with Type.Optional(...) after generation, and add constraints inline like Type.String({ format: "email", minLength: 1 }) which AJV enforces at runtime

Tips & Best Practices

• Compile Ajv schemas once and cache the validator — ajv.compile is expensive and calling it per request silently tanks throughput
• Use the TypeCompiler from @sinclair/typebox/compiler (TypeBox's own JIT) instead of Ajv when you want zero extra dependencies and the fastest check — TypeCompiler.Compile(T).Check(data) returns a boolean
• Type.Optional(Type.String()) makes a key optional (may be absent); for a present-but-nullable field use Type.Union([Type.String(), Type.Null()]) — these are not the same thing
• Enable AJV options addFormats (the ajv-formats package) before using format: "email" / "uri" / "date-time" — without it AJV ignores format keywords entirely and your validation passes everything
• Use Type.Record(Type.String(), Type.Number()) for dictionary-shaped objects with dynamic keys, which the generator cannot infer from a fixed sample
• In Fastify, set ajv.coerceTypes carefully: query/params strings get coerced to numbers, but you usually want coercion off for JSON request bodies to catch type mistakes

Frequently Asked Questions

Real-world Examples

{
  "email": "[email protected]",
  "displayName": "Ada",
  "age": 36,
  "marketingOptIn": true,
  "referralCode": null
}

import { Type, Static } from '@sinclair/typebox';

export const CreateUser = Type.Object({
  email: Type.String(),
  displayName: Type.String(),
  age: Type.Integer(),
  marketingOptIn: Type.Boolean(),
  referralCode: Type.Null(),
});

export type CreateUser = Static<typeof CreateUser>;

// In a Fastify route:
// fastify.post('/users', { schema: { body: CreateUser } }, handler)

{
  "id": 1024,
  "tags": ["a", "b"],
  "owner": {
    "name": "Grace",
    "verified": true
  }
}

import { Type, Static } from '@sinclair/typebox';
import Ajv from 'ajv';

export const Record = Type.Object({
  id: Type.Integer(),
  tags: Type.Array(Type.String()),
  owner: Type.Object({
    name: Type.String(),
    verified: Type.Boolean(),
  }),
});

export type Record = Static<typeof Record>;

const ajv = new Ajv();
const validate = ajv.compile(Record); // compile ONCE
export function isRecord(data: unknown): data is Record {
  return validate(data);
}

Related Tools