Schema Markup Validator

A Schema Markup Validator helps you inspect structured data on a website and identify problems with its markup. Use schema validation to check how a page describes its content through Schema.org types and properties, review detected entities, and troubleshoot issues before publishing changes. It is useful for developers, website owners, and SEO professionals who need to ensure their structured data is correctly implemented.

What Is a Schema Markup Validator?

A Schema Markup Validator is a tool that checks structured data written with the Schema.org vocabulary. Structured data adds machine-readable information to a webpage, helping search engines and other software interpret what the page represents. For example, a website can identify a business, article, product, person, event, or recipe using specific schema types and properties.

Schema markup describes the meaning of webpage content rather than simply changing its visual appearance. A product page might include a product name, brand, image, and offer details. An article might identify its headline, author, publication date, and publisher. The markup organizes these details into a format that software can interpret.

A validator examines the markup and helps identify syntax mistakes, incorrectly defined values, and unusual combinations of schema types and properties. Depending on the validator, it may also display structured data extracted from a webpage, making it easier to understand how the information is connected.

What Does a Schema Markup Validator Check?

The precise checks depend on the validator, but a comprehensive tool can help you review several important areas:

• Markup syntax: Identifies malformed structured data, such as invalid JSON-LD syntax or incorrectly formatted markup attributes.
• Schema types: Helps confirm that types such as Organization, Article, and Product are recognized in the Schema.org vocabulary.
• Properties and values: Helps inspect properties such as name, url, author, and description, including their values and expected usage.
• Entity relationships: Shows how entities and nested properties connect, such as an article referring to its author or publisher.
• Detected structured data: Some validators display the data extracted from a page, helping you find unexpected, missing, or duplicated markup.
• Potential schema issues: May flag unfamiliar properties or unusual combinations that deserve further review.

A validation warning does not always mean the markup is invalid. Schema.org supports a flexible vocabulary, so interpret each reported issue in context. Check the relevant type and property definitions before changing markup that may be valid for your use case.

Supported Schema Markup Formats

Schema.org vocabulary can be represented using multiple formats. Three widely used formats for structured data are JSON-LD, Microdata, and RDFa. The format you choose depends on your website, implementation requirements, and existing markup.

JSON-LD is a common choice for modern websites because it keeps structured data separate from most visible page markup. However, JSON-LD is not the only valid option. Microdata and RDFa can also represent Schema.org information when implemented correctly.

How to Validate Schema Markup

Following a consistent validation process helps you identify markup problems before and after deploying changes. The exact steps depend on whether your validator accepts a webpage URL, a code snippet, or both.

1. Choose the page or markup you want to test

Identify the webpage whose structured data you want to inspect. You can also prepare the relevant markup snippet if the validator supports direct code input. For a published page, use the correct public URL rather than an unrelated page on the same domain.

2. Run the schema validation

Submit the page URL or paste the structured data into the appropriate input field. Run the test and allow the validator to process the available markup. When testing a live page, make sure the page is accessible and that the relevant structured data is present in the version being tested.

3. Review detected items and reported issues

Inspect the schema types, properties, values, and entity relationships that the validator identifies. Read each error or warning carefully instead of assuming that every message requires the same fix. Where available, use the reported location or code details to find the relevant part of the markup.

4. Correct the markup

Fix syntax errors, correct misspelled types or properties, and make sure values use the appropriate data types. Confirm that the markup accurately describes the page and does not contain contradictory or outdated information. If a warning concerns a property combination, check the relevant Schema.org definition before removing it.

5. Validate the updated version

Run the test again after making changes. If you updated a live website, confirm that the published version contains the corrected markup. If the page uses caching, a content management system, or a plugin that generates structured data, check the rendered page rather than relying only on the code saved in the editor.

6. Check Google rich result eligibility separately

If your goal is to qualify for an eligible Google Search feature, test the page using Google's Rich Results Test as well. This provides a separate check for Google-supported rich result features and their specific requirements.

Example of Schema Markup in JSON-LD

The following example describes a fictional organization using JSON-LD and Schema.org properties. Replace the example details with accurate information about the organization you are describing.

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Example Company",
  "url": "https://example.com",
  "description": "A fictional example organization."
}

The @context property identifies the Schema.org vocabulary. The @type property specifies that the entity is an organization. The name, url, and description properties provide information about that entity.

Correct JSON formatting is only one part of successful schema implementation. The selected type and properties must also make sense for the entity, and the published information must accurately represent the website. Do not copy sample values into a production website without replacing them with real information.

Schema Markup Validator vs. Google Rich Results Test

The Schema Markup Validator and Google's Rich Results Test serve related but different purposes. Knowing the difference helps you select the correct tool for your task.

Neither tool guarantees that Google will display a rich result. Even technically valid markup may not qualify for a specific feature, and eligible pages are not guaranteed to receive enhanced search presentations. Google also considers its feature requirements and other signals when determining what to show.

Common Schema Markup Errors and How to Fix Them

Structured data problems can originate in manually written code, website themes, SEO plugins, or content management systems. These are common issues to review when a validator reports unexpected results.

Invalid JSON-LD syntax

Missing commas, unmatched braces, incorrectly quoted strings, and trailing commas can make a JSON-LD object invalid. Review the JSON structure carefully and correct syntax issues before investigating other schema problems.

Incorrect schema types or properties

A misspelled type or property may prevent a validator from interpreting the markup as intended. Check the exact name against Schema.org and make sure that each property is used in an appropriate context.

Incorrect value formats

Some properties expect a particular kind of value, such as a URL, date, number, text string, or nested entity. Supplying an incompatible value can lead to validation problems or unexpected interpretations. Use the value format appropriate for the property.

Markup that does not match page content

Structured data should accurately represent the information available to users. For example, product prices, article authors, business details, and review information should not be fabricated or inconsistent with the relevant page. Review the visible content alongside the schema values.

Duplicate or conflicting structured data

A theme and an SEO plugin may generate markup for the same entity. Multiple blocks are not automatically wrong, but duplicated or conflicting information can make the page's meaning less clear. Inspect the extracted entities, identify where each block originates, and consolidate or correct markup when necessary.

Assuming valid schema guarantees rich results

A schema validator checks general structured data, not every requirement for each Google Search feature. If markup passes schema validation but a rich result is unavailable, use the Rich Results Test and review Google's documentation for the relevant feature.

Why Use a Schema Markup Validator?

Schema validation is useful throughout website development and technical SEO. It helps you review structured data before publication, troubleshoot changes after deployment, and understand how information is represented on a page.

• During technical SEO audits: Review structured data across important pages, including articles, product pages, and business information.
• When publishing new content: Check newly implemented markup before considering the task complete.
• After changing a theme or plugin: Verify that generated schema remains accurate and that changes have not introduced conflicting entities.
• When debugging a rich result: Separate general schema issues from Google-specific eligibility requirements.
• During development: Test schema examples and updated code before deploying them to a production website.

Regular validation can reduce avoidable structured data errors and make markup easier to maintain. It should be part of a broader quality-checking process that also covers the accuracy of page content, crawlability, indexing, and any requirements associated with the search feature you are targeting.

Frequently Asked Questions