Generate a JSON Schema from an API Request Payload

A POST /orders body with required and additional-property defaults left on produces a schema AJV uses to reject both missing and unexpected keys.

Sample request body:
{ "customerId": "c_91", "amount": 4200, "currency": "USD" }

Schema title: CreateOrderRequest  ·  required: ON  ·  additionalProperties: OFF

Generated:
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "CreateOrderRequest",
  "type": "object",
  "properties": {
    "customerId": { "type": "string" },
    "amount": { "type": "integer" },
    "currency": { "type": "string" }
  },
  "required": ["customerId", "amount", "currency"],
  "additionalProperties": false
}

The Draft-07 output compiles unchanged in AJV 8. additionalProperties:false makes the typo'd curency key fail.

const Ajv = require('ajv');
const ajv = new Ajv({ allErrors: true });
const validate = ajv.compile(require('./CreateOrderRequest.schema.json'));

validate({ customerId: 'c_91', amount: 4200, curency: 'USD' });
// => false
// errors: [{ keyword: 'required', params: { missingProperty: 'currency' } },
//          { keyword: 'additionalProperties', params: { additionalProperty: 'curency' } }]

A sample with phone: null infers "type":"null", which then rejects any real phone string. Convert to a nullable union by hand.

Sample: { "name": "Sue", "phone": null }

Generated property (wrong for real traffic):
  "phone": { "type": "null" }

AJV against { name:'Sue', phone:'+15551234' } => false (type must be null)

Manual fix:
  "phone": { "type": ["string", "null"] }

Now both null and a string pass.

Generate with required ON to get the full key list, then prune. PATCH typically requires nothing, so empty the required array.

Generated (required ON):
  "required": ["customerId", "amount", "currency"]

For PATCH /orders/:id, keep additionalProperties:false but drop required:
  "required": []

Keeps the unknown-key rejection while allowing partial bodies.

The Draft-07 output is not express-validator's native schema format, but you can validate with AJV inside a middleware and feed errors to express-validator's error shape.

const Ajv = require('ajv');
const validate = new Ajv().compile(require('./CreateOrderRequest.schema.json'));

function validateBody(req, res, next) {
  if (validate(req.body)) return next();
  return res.status(400).json({ errors: validate.errors });
}

app.post('/orders', validateBody, createOrder);

{ "middleName": null } infers { "type": "null" }. AJV then rejects a real string in that field. The generator has no nullable inference — change the property to { "type": ["string", "null"] } (Draft-07) or add nullable: true if you are targeting OpenAPI 3.0. Always check every null in your sample.

Item schemas are merged by top-level type only. [{"a":1},{"b":2}] — both items are objects, so the merge returns the FIRST item's schema and the result describes only a; b is silently dropped from items.properties. Generate from an array whose first element contains every field, or from a single complete object.

"alice@x.com" infers "type":"string", not format:"email". The generator emits structural types only. Add format, pattern, enum, minLength/maxLength, minimum/maximum, and minItems by hand — these are exactly the rules that make request validation strict.

The Allow additional properties setting writes additionalProperties on the top-level object only. Nested objects (e.g. body.address) get no additionalProperties, so AJV accepts unknown keys inside them. Add additionalProperties: false to each nested object manually if you need deep strictness.

.ndjson/.jsonl are accepted by extension, but the tool runs JSON.parse on the whole file as one value. A file with one object per line throws Unexpected non-whitespace character after JSON. Wrap your log lines in a [ ... ] array first, or extract one line and generate from that single request.

Parsing is strict JSON.parse — { "a": 1, } or // comment throws Expected double-quoted property name in JSON. Run the sample through the JSON prettifier or JSON validator to clean it to canonical JSON before generating.

required is only populated when Mark all fields required is on AND the root is an object. For a PATCH-style contract, turn the checkbox off (no required written) or generate with it on and then empty the array. Both yield a valid Draft-07 schema with no required fields.

If the sample is a top-level array (e.g. a bulk endpoint body), the schema root is {"type":"array","items":...}. No required and no additionalProperties are written, because both apply only to object roots. The item schema follows the array merge rules.

Free JSON processing caps at 2,000,000 bytes (2 MB). A multi-megabyte response dump is more sample than you need for a schema — trim it to one representative object. Pro raises the limit to 100 MB if you genuinely must process a large file.