How do I mark a field as required in JSON Schema?

Use the "required" keyword on an object schema. It takes an array of property name strings that must be present in the validated object: {"type": "object", "required": ["id", "email"], "properties": {"id": {"type": "integer"}, "email": {"type": "string", "format": "email"}, "name": {"type": "string"}}}. Here, "id" and "email" are required; "name" is optional. The "required" keyword must be placed on the object schema itself, not inside individual property schemas. If any required field is absent, the validator reports a validation error identifying which property is missing.

Does required in JSON Schema apply to nested objects?

Yes, but each object needs its own "required" array. The top-level "required" only applies to the top-level object's keys. For nested objects, add a "required" array inside the nested object schema: {"type": "object", "required": ["profile"], "properties": {"profile": {"type": "object", "required": ["displayName"], "properties": {"displayName": {"type": "string"}}}}}. The top-level required makes "profile" mandatory, and the nested required makes "profile.displayName" mandatory. There is no way to make all nested fields required in a single declaration — each level must declare its own required array.

What happens if a required field is missing during validation?

The validator reports a validation error. The error typically includes the path to the missing field and a message like "required property 'email' missing" or "must have required property 'email'". In Ajv (the most popular JavaScript JSON Schema validator), the error object has instancePath pointing to the parent object and params.missingProperty naming the absent key. Validation fails immediately for that object — other required fields are also checked and their errors are reported together in most validators, giving you a complete list of all missing fields at once.

JSON Schema Required Fields: Examples and Common Mistakes

Q: What is the difference between required and not having a property at all?

If a property is listed in "properties" but not in "required", it is optional — the object can include or omit it. If a property is in "required" but not in "properties", the object must have a key with that name, but its value is unconstrained (any value, including null, is accepted). This is technically valid JSON Schema but unusual in practice. The "required" keyword only checks key presence, not value. A field listed in "required" with a value of null will pass required validation — to also forbid null, add a type constraint that excludes null to the property schema.

Q: Can I make all properties required by default?

JSON Schema has no built-in keyword to make all properties required by default. You must list each required property explicitly in the "required" array. However, some code generation tools and schema editors can auto-populate "required" with all defined property names. An alternative approach is using "minProperties" to require a minimum number of properties, but this does not specify which ones. If you find yourself always making all properties required, consider whether "additionalProperties": false combined with an explicit required list is the right pattern for your use case.

Q: How does required interact with additionalProperties: false?

These two keywords work together but address different concerns. "required" specifies which keys must be present. "additionalProperties": false specifies that only keys listed in "properties" (and "patternProperties") are allowed — no extra keys. Together, they create a strict object schema: {"type": "object", "required": ["id", "name"], "properties": {"id": {"type": "integer"}, "name": {"type": "string"}}, "additionalProperties": false}. This schema requires both "id" and "name", allows only those two keys, and rejects any object that includes extra keys or is missing required ones. This is the recommended pattern for strict API contract validation.

Last updated: May 12, 2026

The JSON Schema required keyword is an array of property name strings that must be present in the validated object — missing any 1 of them fails validation immediately. It belongs alongside the properties keyword on the same object schema: "required": ["id", "email"]. An empty required: [] makes no field mandatory. Adding a property to required only checks presence — it does not constrain the value; you still need an entry in properties for type validation. This guide covers required vs optional fields, the absent vs null distinction (a null value satisfies required; an absent key does not), conditionally required fields using if/then/else, nested object required arrays, the dependentRequired keyword for field dependencies, and common validator behavior differences between Ajv, jsonschema, and tv4.

Testing required fields? Paste your schema and sample data into Jsonic's JSON Schema Validator to see exactly which property is missing.

Validate JSON Schema

Basic required example

{
  "type": "object",
  "properties": {
    "id": { "type": "integer" },
    "email": { "type": "string", "format": "email" },
    "name": { "type": "string" }
  },
  "required": ["id", "email"]
}

This requires id and email. The name property is allowed but optional.

Required does not define type

required only checks whether a property exists. The property's value is checked by its schema under properties.

{
  "type": "object",
  "properties": {
    "active": { "type": "boolean" }
  },
  "required": ["active"]
}

Nested required fields

For nested objects, each object has its own required array.

{
  "type": "object",
  "properties": {
    "profile": {
      "type": "object",
      "properties": {
        "displayName": { "type": "string" }
      },
      "required": ["displayName"]
    }
  },
  "required": ["profile"]
}

The top-level required makes profile mandatory. The nested required makes profile.displayName mandatory.

Required fields in arrays of objects

Put required inside the items object schema so every item is checked. The array of objects guide covers this pattern in more depth.

{
  "type": "array",
  "items": {
    "type": "object",
    "properties": {
      "sku": { "type": "string" },
      "quantity": { "type": "integer", "minimum": 1 }
    },
    "required": ["sku", "quantity"]
  }
}

Common mistakes

Mistake	Fix
Writing `"required": true`	Use an array: `"required": ["id"]`
Putting required inside a property schema	Put it on the parent object schema
Expecting required to reject null	Add a type rule that excludes null
Forgetting nested required arrays	Add required to each nested object schema

Validate required fields online

Use Jsonic's JSON Schema Validator to test required-field errors before shipping an API contract or config schema.

Open Schema Validator

Frequently asked questions

How do I mark a field as required?

Use the required keyword on the object schema with an array of property name strings: {"required": ["id", "email"]}. Properties not listed in required are optional.

Does required apply to nested objects?

Each object needs its own required array. The top-level required only applies to top-level keys. Add a separate required inside each nested object schema to require its properties.

What happens if a required field is missing?

The validator reports an error identifying which property is missing. Ajv includes instancePath (the parent object path) and params.missingProperty (the absent key). All missing required fields are reported together.

What is the difference between required and not having a property?

A property in properties but not in required is optional. A property in required but not properties must be present but can have any value. The required keyword only checks key presence, not the value.

Can I make all properties required by default?

There is no built-in keyword for this. You must list each required property explicitly. Some code generation tools can auto-populate required with all defined property names when generating schemas.

How does required interact with additionalProperties: false?

required specifies which keys must be present; additionalProperties: false rejects keys not listed in properties. Together they create a strict schema: all listed fields must appear and no extra fields are allowed.