Additional Properties is the part of a schema or object definition that controls whether fields not listed in the schema are allowed. In JSON Schema and similar validation systems, it can permit, reject, or further constrain extra keys in an object, which affects how strictly incoming data is validated.
What Additional Properties Does in a Schema
Additional Properties defines the handling of object fields that are not explicitly listed in a schema. In practice, it is the rule that decides whether unexpected keys are accepted, rejected, or checked against further constraints, which makes it a core part of how strict or permissive a data contract is.
In JSON Schema and similar validators, this setting matters because schemas rarely describe every possible input forever. When new, misspelled, or malicious fields appear, the validator either lets them through or blocks them, and that choice shapes the reliability of downstream processing.
Why Strictness Matters for Validation
A permissive schema can be useful when an application must tolerate extension fields, forward-compatible payloads, or vendor-specific metadata. A strict schema is better when the receiving system depends on a fixed object shape, because unknown properties can become hidden inputs that bypass assumptions in application logic.
Additional Properties is therefore not just a syntactic toggle, it is part of data governance at the boundary of a system. If teams do not decide this deliberately, different services may interpret the same payload differently, which creates subtle integration bugs and inconsistent enforcement.
How It Changes Object Processing
When additional fields are allowed, they may be preserved for later use, ignored by the application, or validated against a pattern or nested schema. When they are disallowed, the entire object can fail validation as soon as an unrecognised field is encountered, which is often the safest choice for APIs with fixed contracts.
The main practical difference is whether validation defines only the known fields or the whole object envelope. That distinction affects request filtering, serialization, schema evolution, and whether producers and consumers can safely evolve at different speeds.
Common Uses and Design Trade-offs
Teams often allow additional properties in extensible formats, plugin ecosystems, or schema-driven metadata models where new keys may be introduced without breaking older clients. They often reject them in authentication, authorisation, configuration, and other high-trust interfaces where unknown input should be treated as suspicious.
The trade-off is flexibility versus precision. More flexibility can reduce breakage during change, but it also reduces certainty about what the system will accept and process, so the best choice depends on whether the object is meant to be open-ended or tightly controlled.
Risk and Threat Considerations
Additional Properties can create exposure when systems assume the schema fully describes the input but the validator still accepts extra keys. Attackers and buggy clients can use unexpected fields to smuggle data into downstream components, trigger inconsistent parsing, or exploit application code that reads fields the schema author never intended to permit.
Failure mechanism: A validation layer permits unknown properties while a later component trusts or interprets them, creating a gap between declared and actual object behaviour.
Impact: That gap can lead to logic abuse, hidden configuration changes, silent data pollution, or security control bypass when the extra fields influence state, privilege, routing, or policy decisions.
Standards & Framework Alignment
This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.
OWASP API Security Top 10 addresses the attack and risk surface, while OWASP ASVS and NIST SP 800-53 Rev 5 set the governance and control requirements practitioners need to meet.
| Framework | Control / Reference | Relevance |
|---|---|---|
| OWASP ASVS | V2 — Validation and Business Logic | Additional properties changes how input validation accepts object fields. |
| V14 — Data Protection | Extra properties can alter what data is accepted and stored in a structured object. | |
| Recommendation — Validate object shapes strictly and reject unexpected fields where business logic depends on a fixed contract. Limit accepted object fields to the minimum data required for the transaction. | ||
| NIST SP 800-53 Rev 5 | SI-10 — Information Input Validation | This term governs whether unexpected input fields are accepted or rejected. |
| Recommendation — Apply input validation checks that reject unapproved object properties before processing. | ||
| OWASP API Security Top 10 | API8 — Security Misconfiguration | Permissive property handling can become a configuration weakness at API boundaries. |
| Recommendation — Configure API validators to block unexpected request properties unless the contract explicitly allows extension fields. | ||
Practitioner Guidance
Why practitioners should care: Treat Additional Properties as a contract decision, not a formatting detail. The right setting depends on whether the object is supposed to be closed, extensible, or partially open with explicit exceptions.
Common misunderstanding: Many teams assume that schema validation alone guarantees input safety. In reality, the value of Additional Properties depends on how the rest of the stack handles unexpected keys after validation.
Practitioner takeaway: If the object is security-sensitive or stateful, default to rejecting unknown fields unless there is a clearly documented reason to preserve them.
Related resources from NHI Mgmt Group
Deepen Your Knowledge
Free weekly newsletter
Subscribe to the NHI & AI Identity Journal
The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.
Bonus 33% off our NHI Course when you subscribe.
Reviewed and updated by the NHIMG editorial team on November 16, 2026.
NHI Mgmt Group — the #1 independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org