Quick answer
Many Schema.org types have required or recommended properties.
Schema.org Missing Required Property
Many Schema.org types have required or recommended properties. Missing them can prevent rich results or cause validation warnings.
Common causes
- Using a type without checking its required properties (e.g. Product without name).
- Nested objects missing required fields (e.g. Offer without price).
- Omitting recommended properties that validators expect.
How to fix
- Check the Schema.org definition for your type and add all required properties.
- Use the Schema.org Validator to see which properties are missing.
- Add recommended properties (e.g. description, image) for better eligibility.
Schema.org missing required property errors happen when structured data for a page, product, article, event, or other entity does not include fields that the schema type expects. This validator helps you identify those gaps so your markup is more likely to parse cleanly and qualify for rich result eligibility where supported. It is useful for developers, SEO teams, content publishers, and technical auditors who need to check JSON-LD, Microdata, or RDFa for completeness and consistency. By finding missing properties early, you can reduce validation warnings, improve machine readability, and make your structured data easier for search engines and AI systems to interpret.
How This Validator Works
This checker reviews your Schema.org markup against the expected property set for the selected type. It looks for required fields, commonly recommended fields, and structural issues that may prevent parsers from understanding the entity correctly. In practice, that means checking whether the markup includes the minimum information needed for the schema type, such as name, image, author, date, offer, or location depending on the entity.
- Identifies missing required properties for the schema type
- Highlights recommended fields that improve completeness
- Helps surface markup issues before deployment
- Supports structured data used for search features and knowledge systems
Common Validation Errors
- Missing required property: A mandatory field for the selected Schema.org type is absent.
- Incomplete nested object: A property exists, but its child fields are missing or malformed.
- Wrong schema type: The page uses a type that does not match the content, causing expected fields to differ.
- Empty or placeholder values: Required properties are present but contain blank, generic, or invalid data.
- Markup mismatch: The visible page content does not support the entity described in the structured data.
- Syntax issues: JSON-LD formatting, Microdata attributes, or RDFa structure prevent correct parsing.
Where This Validator Is Commonly Used
- Product pages with Offer, Review, or AggregateRating markup
- Articles, blog posts, and news pages using Article or NewsArticle
- Local business pages with Organization or LocalBusiness schema
- Event pages with date, location, and organizer data
- Recipe pages with ingredients, instructions, and nutrition fields
- FAQ pages and support content with structured Q&A markup
- Technical SEO audits and structured data QA workflows
Why Validation Matters
Structured data is a machine-readable layer that helps search engines and other systems understand page meaning. When required properties are missing, parsers may still read parts of the markup, but the entity can become incomplete or less useful. Validation helps ensure your schema is consistent, easier to maintain, and aligned with the intended content. It also supports better internal QA, especially on large sites where templates, CMS fields, and dynamic data can introduce errors.
Technical Details
Schema.org defines a shared vocabulary for describing entities on the web. Different schema types have different property expectations, and those expectations may vary depending on the implementation format and the use case. Most modern sites use JSON-LD, but Microdata and RDFa are also supported in some environments. This validator is most useful when you need to confirm that the selected type includes the fields needed for parsing, indexing, and rich result eligibility checks.
| Format | What to Check |
|---|---|
| JSON-LD | Object structure, required properties, nested entities, and valid values |
| Microdata | Itemtype, itemprop usage, and completeness of entity fields |
| RDFa | Vocabulary mapping, property declarations, and entity relationships |
| Schema type selection | Whether the chosen type matches the page content and expected properties |
For best results, compare your markup against the official Schema.org definition for the selected type and any search engine documentation relevant to rich results.
FAQ
What does “missing required property” mean in Schema.org?
It means the structured data for a page is missing a field that the selected schema type expects. For example, a Product schema may require or strongly depend on properties like name and offer-related details. The exact expectation depends on the entity type and the parser or validator being used.
Does missing a required property always break structured data?
Not always. Some parsers may still read the markup, but the entity can be incomplete or less useful. In some cases, missing fields can prevent rich result eligibility or trigger warnings. The impact depends on the schema type, the missing field, and how the data is consumed.
Which schema formats can have missing required property issues?
JSON-LD, Microdata, and RDFa can all have completeness issues. JSON-LD is the most common format on modern sites, but the same underlying problem can occur in any structured data syntax if a required field is absent, empty, or incorrectly nested.
How do I know which properties are required?
Check the Schema.org definition for the specific type you are using, then compare it with any search engine guidance for rich results. Some properties are required by the vocabulary, while others are recommended for better eligibility or interpretation. The exact set can vary by use case.
Can recommended properties matter as much as required ones?
Yes, in practice they often do. Recommended properties may not be mandatory for basic parsing, but they can improve completeness, reduce ambiguity, and support richer search features. For example, adding author, image, or date information can make content easier to interpret.
Why does my markup validate in one tool but not another?
Different tools may apply different rules. One validator may check only syntax, while another checks schema completeness or rich result requirements. A page can be syntactically valid but still missing properties expected by a specific schema type or search feature.
Should I add every possible property to my schema?
No. Add properties that accurately describe the page and its entity. Overfilling markup with irrelevant or fabricated fields can create confusion and reduce trust. The goal is accurate, complete, and maintainable structured data, not maximum property count.
What is the safest way to fix missing required properties?
Start with the official schema definition for the type, then map each required field to real page content or reliable data sources. If the page cannot support a property, consider whether the schema type is the right one. Accurate markup is usually better than forcing a mismatched entity.
Related Validators & Checkers
- Schema.org Validator — general structured data validation
- JSON-LD Validator — checks JSON-LD syntax and structure
- Microdata Validator — validates Microdata markup
- RDFa Validator — checks RDFa structured data
- Structured Data Checker — broader schema and entity review
- Rich Results Checker — evaluates markup for search feature readiness
FAQ
- Which properties are required for Product?
- At minimum, name is expected. For rich results, image and offers (with price) are often required.
- Does Google require all Schema.org properties?
- Google has its own guidelines; use Google's Rich Results Test to check eligibility.
Fix it now
Try in validator (prefill this example)