JSON Schema to Zod

Overview

You send a JSON Schema and name the Zod major you are on, and we return TypeScript source declaring one constant per definition and one for the root, with the optional z.infer type aliases beside them. The mapping is published per major, because Zod 4 moved string formats to top-level factories and changed z.record, so a single undifferentiated target would emit code that fails to compile on one of the two. Anything Zod cannot express — if/then/else, dependent schemas, propertyNames, contains, unevaluated keywords, not — becomes z.unknown() with a warning naming the pointer and the construct and lossy set true, or a refusal if you would rather not ship a silent gap. Nothing here compiles or runs JavaScript: the answer is text.

Generated TypeScript types vanish at run time, so the boundary where untrusted JSON actually arrives is exactly where they stop helping. A runtime validator is the missing half, and hand-writing it beside a schema is how the two drift apart.

When to use it

Scope

Non-goals

• We never compile, evaluate or execute the code we emit — zod is not on our classpath and no script engine is
• We never validate a document: this produces a validator, it does not run one
• We never guess the Zod major; the mapping differs, so you declare it
• We never silently drop a construct: anything unmappable is warned or refused
• We never fetch a reference outside the document you sent

Properties

Capabilities

Cost & billing

Flat rate per invocation

File handling

How we handle your data

Input schema

Output schema

API contract

curl -sS -X POST "$BASE/v1/execute" -H "Authorization: Bearer $KEY" -H 'Content-Type: application/json' -d '{"skillKey":"schema.convert_json_schema_to_zod","input":{"schema":{"type":"object","properties":{"id":{"type":"string"}},"required":["id"]}}}'

import { Squillify } from "@squillify/sdk";

const sq = new Squillify({ apiKey: process.env.SQUILLIFY_API_KEY });

const { output } = await sq.execute("schema.convert_json_schema_to_zod", {"options":{"rootSchemaName":"Order"},"schema":{"type":"object","properties":{"id":{"type":"string","format":"uuid"},"total":{"type":"number","minimum":0},"shipTo":{"$ref":"#/$defs/address"}},"required":["id","total"],"$defs":{"address":{"type":"object","properties":{"city":{"type":"string"}},"required":["city"]}}}});

Errors

Other limits

Limitations

• We never compile, evaluate or execute the code we emit — zod is not on our classpath and no script engine is
• We never validate a document: this produces a validator, it does not run one
• We never guess the Zod major; the mapping differs, so you declare it
• We never silently drop a construct: anything unmappable is warned or refused
• We never fetch a reference outside the document you sent
• Validating a document against a schema, which schema.validate_json does
• Producing compile-time types only, which schema.convert_json_schema_to_typescript does

How to call

POST /v1/execute (requires authentication)

{
  "skillKey": "schema.convert_json_schema_to_zod",
  "input": {
    "options": {
      "rootSchemaName": "Order"
    },
    "schema": {
      "type": "object",
      "properties": {
        "id": {
          "type": "string",
          "format": "uuid"
        },
        "total": {
          "type": "number",
          "minimum": 0
        },
        "shipTo": {
          "$ref": "#/$defs/address"
        }
      },
      "required": [
        "id",
        "total"
      ],
      "$defs": {
        "address": {
          "type": "object",
          "properties": {
            "city": {
              "type": "string"
            }
          },
          "required": [
            "city"
          ]
        }
      }
    }
  }
}

Examples

{
  "options": {
    "rootSchemaName": "Order"
  },
  "schema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string",
        "format": "uuid"
      },
      "total": {
        "type": "number",
        "minimum": 0
      },
      "shipTo": {
        "$ref": "#/$defs/address"
      }
    },
    "required": [
      "id",
      "total"
    ],
    "$defs": {
      "address": {
        "type": "object",
        "properties": {
          "city": {
            "type": "string"
          }
        },
        "required": [
          "city"
        ]
      }
    }
  }
}

{
  "zodCode": "import { z } from \"zod\";\n\nexport const AddressSchema = z.object({\n  city: z.string(),\n});\n\nexport type Address = z.infer<typeof AddressSchema>;\n\nexport const OrderSchema = z.object({\n  id: z.uuid(),\n  total: z.number().min(0),\n  shipTo: AddressSchema.optional(),\n});\n\nexport type Order = z.infer<typeof OrderSchema>;\n",
  "emittedRootName": "OrderSchema",
  "lossy": false,
  "summary": {
    "nodeCount": 22,
    "declarationCount": 2,
    "codeBytes": 317,
    "truncated": false
  },
  "targetApplied": "ZOD_4",
  "declarations": [
    "AddressSchema",
    "OrderSchema"
  ],
  "warnings": []
}

{
  "options": {
    "rootSchemaName": "Event",
    "emitTypeExports": false
  },
  "schema": {
    "type": "object",
    "properties": {
      "payload": {
        "not": {
          "type": "string"
        }
      }
    }
  }
}

{
  "zodCode": "import { z } from \"zod\";\n\nexport const EventSchema = z.object({\n  payload: z.unknown().optional(),\n});\n",
  "emittedRootName": "EventSchema",
  "lossy": true,
  "summary": {
    "nodeCount": 6,
    "declarationCount": 1,
    "codeBytes": 103,
    "truncated": false
  },
  "targetApplied": "ZOD_4",
  "declarations": [
    "EventSchema"
  ],
  "warnings": [
    {
      "pointer": "/properties/payload",
      "construct": "not",
      "code": "ZOD_CONSTRUCT_UNSUPPORTED",
      "message": "This construct has no Zod equivalent, so the generated validator accepts any value here."
    }
  ]
}

Recommended use cases

• Generate a runtime validator to sit beside generated TypeScript types
• Turn a published tool schema into a Zod parser for a TypeScript client
• Check, before adopting Zod, how much of a schema it can actually express

Avoid for

• Validating a document against a schema, which schema.validate_json does
• Producing compile-time types only, which schema.convert_json_schema_to_typescript does

Related skills

Composable with

Safety & privacy

• Runs without calling any external service.
• Your payloads are never stored permanently.
• Telemetry captures metadata only — never your payload contents.
• We never train models on your payloads.
• No human reviews your payloads.

Tags