How to Use the Schema Markup Validator

What schema markup does

Schema markup, also known as structured data, is a form of microdata that you can add to your website's HTML. It helps search engines understand the content and context of your web pages more precisely. When search engines better understand your content, they can display it in richer formats in search results. These rich formats, called rich results or rich snippets, can include star ratings, product prices, event dates, and more.

For example, a recipe website might use schema markup to tell search engines about the ingredients, cooking time, and calorie count of a dish. This information can then appear directly in the search results, making the listing more informative and appealing to users.

Schema markup uses a vocabulary defined by schema.org, a collaborative initiative by major search engines including Google, Bing, Yahoo, and Yandex. This standardized vocabulary ensures that information is interpreted consistently across different search platforms.

JSON-LD vs microdata vs RDFa

There are several formats for implementing schema markup. The most common are JSON-LD, Microdata, and RDFa. LemRank's validator focuses on JSON-LD, as it is the format recommended by Google and widely adopted across the web.

• JSON-LD (JavaScript Object Notation for Linked Data): This format is typically embedded within <script type="application/ld+json"> blocks in the HTML <head> or <body> section of a web page. It is preferred because it separates structured data from the visible content of the HTML, making it easier to manage and implement without altering the visual structure of your page.

  Example of JSON-LD for an Article:

  <script type="application/ld+json">
  {
    "@context": "https://schema.org",
    "@type": "Article",
    "headline": "How to Use the Schema Markup Validator",
    "image": [
      "https://example.com/photos/1x1/photo.jpg",
      "https://example.com/photos/4x3/photo.jpg",
      "https://example.com/photos/16x9/photo.jpg"
     ],
    "datePublished": "2024-03-01T08:00:00+08:00",
    "dateModified": "2024-03-02T09:20:00+08:00",
    "author": [{
        "@type": "Person",
        "name": "Jane Doe",
        "url": "https://example.com/profile/janedoe"
      }]
  }
  </script>
  

• Microdata: This format involves adding attributes directly to existing HTML tags. It intertwines the structured data with the visible content.

  Example of Microdata for an Article:

  <div itemscope itemtype="https://schema.org/Article">
    <h1 itemprop="headline">How to Use the Schema Markup Validator</h1>
    <img itemprop="image" src="https://example.com/photos/1x1/photo.jpg" alt="Article image">
    <span itemprop="datePublished">2024-03-01T08:00:00+08:00</span>
    <span itemprop="author" itemscope itemtype="https://schema.org/Person">
      <a itemprop="url" href="https://example.com/profile/janedoe"><span itemprop="name">Jane Doe</span></a>
    </span>
  </div>
  

• RDFa (Resource Description Framework in Attributes): Similar to Microdata, RDFa also integrates structured data within HTML attributes. It is less common for general web content compared to JSON-LD and Microdata.

For practical purposes and ease of implementation, JSON-LD is the recommended format and the primary focus of most modern SEO tools and best practices.

How the validator works

The LemRank Schema Markup Validator is a tool designed to analyze the structured data on any web page. Its primary function is to:

1. Parse Schema Markup: The validator identifies and extracts all <script type="application/ld+json"> blocks from the provided URL. It processes the JSON-LD code contained within these blocks.
2. Validate against Schema.org Standards: Each extracted schema object is checked against the vocabulary and rules defined by schema.org. This validation ensures that the properties and types used are recognized and correctly structured according to the open standard.
3. Check for Google Rich Result Eligibility: Beyond schema.org validation, the tool also evaluates whether the structured data meets Google's specific guidelines for rich results. Not all valid schema.org markup qualifies for Google rich results, as Google has additional requirements and enhancements.
4. Identify Errors and Warnings: The validator reports any errors (syntax issues, missing required properties) and warnings (recommended but not strictly required properties) found in the schema markup.
5. List Qualified Rich Results: For each piece of structured data, the tool indicates which Google rich results it potentially qualifies for, such as "Article," "Product," "Recipe," or "Event." This goes beyond what Google's Rich Results Test offers, which only focuses on Google's specific rich results. LemRank's validator provides a broader perspective by confirming both schema.org validity and Google eligibility.

To use the validator, you simply paste the URL of the webpage you want to analyze into the input field and click "Validate." The tool then fetches the page, parses its structured data, and presents a detailed report outlining its findings.

Fixing common validation errors

When using schema markup, encountering errors or warnings is common. These signals from the validator help you refine your structured data for optimal performance.

Here are some common validation errors and how to address them:

• Missing Required Property: Many schema types define properties that are mandatory for the markup to be considered valid or eligible for rich results.

  • Error: A value for the "name" field is required.

  • Solution: Ensure that all required properties (e.g., name, headline, image, price, url) are included and contain valid data. Refer to the schema.org documentation for the specific type you are implementing.

    {
      "@context": "https://schema.org",
      "@type": "Product",
      "name": "Example Product Name", // Missing "name" would trigger the error
      "description": "A brief description.",
      "offers": { /* ... */ }
    }
    

• Invalid Data Type for Property: Each property expects a certain data type (e.g., Text, URL, Number, Date, another Schema type). Providing an incorrect type can lead to errors.

  • Error: The value provided for "url" is not a valid URL.

  • Solution: Double-check that dates are in ISO 8601 format, numbers are numeric, and URLs are valid web addresses.

    {
      "@context": "https://schema.org",
      "@type": "Event",
      "name": "Summer Festival",
      "startDate": "2024-07-20", // Correct format
      "url": "https://example.com/events/summer-festival" // Correct format
    }
    

• Syntax Errors in JSON-LD: JSON-LD is a strict format. Minor errors like misplaced commas, missing curly braces, or unquoted property names can break the entire block.

  • Error: Unexpected token } in JSON at position 123

  • Solution: Use a JSON linter or validator (separate from the schema validator) to check your JSON-LD syntax before embedding it. Pay close attention to commas between key-value pairs, square brackets for arrays, and curly braces for objects.

    {
      "@context": "https://schema.org",
      "@type": "Article", // Missing comma after this line could be an error
      "headline": "Article Title"
    }
    

• Value Out of Range/Invalid: Some properties have specific constraints on their values.

  • Warning: The value of "aggregateRating.ratingValue" must be between 1 and 5.
  • Solution: Ensure that ratings, prices, or other numerical values fall within the expected ranges.

• Multiple Definitions for a Single Page: While technically not an error, having multiple, conflicting schema types on a page (e.g., two different Article markups for the same content) can confuse search engines.

  • Solution: Consolidate schema markup where possible, or ensure each schema block applies to a distinct, clearly identifiable entity on the page.

Address errors first, as they prevent search engines from parsing your schema correctly. Then, review warnings to improve the completeness and quality of your structured data, which can enhance your chances of appearing in rich results.

Which rich results each schema type unlocks

Different schema types can qualify your content for specific rich results in Google Search. The LemRank validator shows which rich results your schema could unlock, depending on its specific type and content.

Here is a table illustrating some common schema types and the rich results they may enable:

Schema Type	Common Rich Results
Article	News Article rich result, Blog Post rich result, AMP rich result.
BreadcrumbList	Breadcrumb navigation in search results.
Course	Course listings with details like title, provider, and description.
Event	Event snippets showing date, location, and time.
FAQPage	FAQ rich result, displaying questions and answers directly in search.
HowTo	How-to rich result, providing step-by-step instructions.
ImageObject	Enhances image appearance in Google Images, though not a standalone rich result in web search.
JobPosting	Job listing rich result with details like title, company, and location.
LocalBusiness	Local business results in maps and local packs, showing address, phone, and hours.
Organization	Enhances corporate contact information and logos in search and Knowledge Panel.
Product	Product rich result, including price, availability, and review ratings.
Recipe	Recipe rich result with star ratings, cooking times, and images.
Review / AggregateRating	Star ratings displayed for products, recipes, books, etc.
VideoObject	Video snippets with thumbnails, descriptions, and duration.

This table is not exhaustive but covers many commonly used schema types. It is important to note that qualifying for a rich result does not guarantee its appearance. Google's algorithms consider various factors, including the quality of the content, site authority, and user relevance, when deciding whether to display rich results.

Testing before you ship

Implementing schema markup can enhance your search visibility, but incorrect implementation can lead to errors or, at worst, penalties. Therefore, testing your schema markup before deploying it to your live site is a critical step.

Here’s why and how to test effectively:

1. Identify Errors Early: Testing on a staging environment or after local development allows you to catch and fix validation errors (missing properties, incorrect data types, syntax issues) before they impact your live site's SEO.
2. Ensure Rich Result Eligibility: The LemRank validator analyzes your schema against Google's rich result guidelines. This helps you confirm that your structured data is correctly formatted to potentially earn rich snippets, not just that it is syntactically correct. This check is more comprehensive than Google's Rich Results Test alone because it surfaces both schema.org validity and Google eligibility. Google's tool only checks eligibility for its own rich results.
3. Prevent Search Console Warnings: Google Search Console reports errors and warnings related to structured data. Proactive validation helps minimize these issues, keeping your Search Console clean and your overall SEO health robust.
4. Confirm Correct Property Population: When using CMS plugins or dynamic data, sometimes values do not populate correctly. Testing verifies that dynamic fields (e.g., product prices, event dates) are correctly rendered in the schema markup.

Testing Workflow:

1. Develop Schema: Write or generate your JSON-LD schema markup code for your content type (e.g., Article, Product, Event).
2. Paste into Validator (Text Mode): If your page is not yet live on a publicly accessible URL, you can copy and paste the raw <script type="application/ld+json"> block directly into the LemRank Schema Markup Validator, treating it as a text input.
3. Review Results: Analyze the validator's output for any errors or warnings. Pay attention to proposed rich results.
4. Make Corrections: Adjust your schema code based on the validator's feedback.
5. Test Staging URL: Once your content, including the schema, is deployed to a staging or development URL, run the validator against that URL. This ensures that the schema is correctly embedded and fetched from the page.
6. Final Review: After all fixes, run one last validation check before pushing changes to your production website.

By integrating testing into your development workflow, you ensure that your structured data is an asset, not a liability, for your website's search performance.

Related

• How to Target Featured Snippets