Generate an OpenAPI components/schemas Entry from JSON

Generate, strip $schema, and paste under components/schemas. Required defaults give you the required list.

Sample: { "id": 42, "email": "a@b.com", "verified": true }
Schema title: User  ·  required: ON

Generated (after removing the $schema line):
{
  "title": "User",
  "type": "object",
  "properties": {
    "id": { "type": "integer" },
    "email": { "type": "string" },
    "verified": { "type": "boolean" }
  },
  "required": ["id", "email", "verified"],
  "additionalProperties": false
}
// Paste under components: schemas: User:

A null sample value yields type:null, which OpenAPI 3.0 does not allow. Replace with nullable:true on the base type.

Generated:  "deactivatedAt": { "type": "null" }

OpenAPI 3.0 (YAML):
  deactivatedAt:
    type: string
    format: date-time
    nullable: true

OpenAPI 3.1 (YAML):
  deactivatedAt:
    type: [string, "null"]
    format: date-time

The generator inlines nested objects. For reuse, move the nested block into its own component and reference it.

Inline (generated):
  address:
    type: object
    properties: { city: {type: string}, zip: {type: string} }

Refactored:
components:
  schemas:
    Address:
      type: object
      properties: { city: {type: string}, zip: {type: string} }
    User:
      type: object
      properties:
        address: { $ref: '#/components/schemas/Address' }

Once User lives under components/schemas, reference it in a response. The validator resolves the $ref.

paths:
  /users/{id}:
    get:
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/User'

OpenAPI specs are usually YAML. Generate the JSON schema here, then convert the block to YAML for openapi.yaml.

1. Generate the component as JSON here, remove the $schema line.
2. Paste into /tool/json-to-yaml to convert to YAML.
3. Drop the YAML under components: schemas: <Name>:
   (YAML preserves key order and types — id stays an integer).

A null sample value infers "type":"null". OpenAPI 3.0 has no null type — Swagger/Redoc validators reject it. Replace with the base type plus nullable: true (3.0) or type: ["string", "null"] (3.1). Check every null in your sample before pasting into the spec.

The generator expands nested objects inline; it does not create separate components/schemas entries with $ref. For reuse across paths, lift each nested object into its own named component manually and reference it. Inline is valid OpenAPI; it's just not DRY.

The output starts with $schema: http://json-schema.org/draft-07/schema#. OpenAPI inline schemas don't use $schema — leave it in and some linters warn. Delete the line; the remaining object is your component body.

A timestamp string is "type":"string", not format:"date-time", and a status field is not an enum. Add format, enum, minimum/maximum, minLength/maxLength, description, and example by hand — these are what make the documented spec useful and strict.

Item schemas merge by top-level type, so an array of objects keeps the FIRST element's shape; later-only keys are dropped from items. Your component then under-documents the array. Generate from a sample whose first array element has every field, or hand-complete items.properties.

The Allow additional properties setting writes additionalProperties on the top-level object only — nested objects get none and will accept unknown keys. Add additionalProperties: false to each nested component manually if your spec needs deep strictness.

The Schema title is written to the root title, but OpenAPI references a component by its MAP KEY under components/schemas (User:), not by title. Choose the map key deliberately; the title is documentation. They can match or differ.

Strict JSON.parse rejects NDJSON (Unexpected non-whitespace character after JSON), trailing commas, and comments. Clean the sample with the JSON prettifier first, and generate from a single object, not a line-delimited log.