What Is Schema Markup? (2026 Guide)

What schema markup is

Schema markup, often referred to as structured data, is code you add to your website to help search engines better understand your content. It provides explicit information about the entities on your page, such as a person, place, product, or event, in a structured format. This structured data allows search engines to go beyond simply crawling text and images; they can interpret the meaning and relationships of information on a page.

For example, a page about a specific recipe might include schema markup to tell search engines:

• The name of the recipe
• The ingredients
• The cooking time
• The calorie count
• User ratings

This explicit labeling helps search engines present your content more effectively to users, often through rich results. Rich results are enhanced search listings that display more information than standard blue-link results, such as star ratings, images, or carousels.

JSON-LD, microdata, RDFa (and why to use JSON-LD)

Schema markup can be implemented using different formats. The three primary formats are JSON-LD, Microdata, and RDFa.

• JSON-LD (JavaScript Object Notation for Linked Data): This is a lightweight data interchange format. Schema markup using JSON-LD is typically embedded within a <script type="application/ld+json"></script> tag in the <head> or <body> section of an HTML document.
• Microdata: Microdata uses HTML attributes to embed semantic markup directly within the existing HTML elements of a page.
• RDFa (Resource Description Framework in Attributes): Similar to Microdata, RDFa uses HTML attributes to add semantic metadata to web pages.

Why to use JSON-LD:

Google explicitly recommends using JSON-LD for implementing schema markup. This recommendation is due to several advantages:

• Ease of implementation: JSON-LD can be added as a distinct block of code, often within the head of the document, without altering the existing HTML structure of the visible page content. This separation makes it easier to manage and update.
• Flexibility: JSON-LD can reference elements across different parts of a page or even across different pages, offering greater flexibility in describing complex relationships.
• Maintainability: Its distinct block structure makes it less prone to errors when making changes to the visible content or the schema itself.

While Microdata and RDFa are still supported, their inline nature can make them more complex to implement and maintain, especially on dynamic websites. Therefore, for most use cases, JSON-LD is the preferred method for adding schema markup.

The 8 schema types with the biggest SEO impact

While schema.org offers a vast taxonomy of schema types, some have a more direct and significant impact on SEO through their potential to generate rich results. Focusing on these types can provide the most value:

1. Article: Used for news articles, blog posts, and other editorial content. It can help search engines understand the article's topic, author, publication date, and provide enhanced listings with an image and publication details.
2. Product: Essential for e-commerce sites. This schema type specifies product details like name, image, description, price, currency, availability, and reviews. It can lead to rich snippets showing product ratings, price, and availability directly in search results.
3. Review / AggregateRating: Applies to individual reviews or aggregated ratings for a product, service, or business. This is crucial for displaying star ratings and review counts in organic search results. It is often nested within Product, LocalBusiness, or Recipe schema.
4. LocalBusiness: Provides specific information about a local business, including its name, address, phone number, operating hours, and services. This can enhance local search results with a knowledge panel and map information.
5. Recipe: Detailed information about food recipes, such as ingredients, preparation steps, cooking time, and nutritional facts. This can generate rich results with images, ratings, and preparation details.
6. Event: Marks up information about events, including name, date, time, location, and ticket information. This helps create rich results for upcoming events, often with direct links for tickets or more information.
7. FAQPage: Used for pages containing a list of questions and answers. This can result in an expandable section of questions and answers directly within the search results, known as FAQ rich snippets.
8. HowTo: Provides a step-by-step guide on how to complete a task. This can generate rich results that display individual steps, images, and tools required for the task.

Implementing these schema types appropriately can significantly increase the visibility and click-through rate of your search listings.

How to add schema to a page

Adding schema markup to a page typically involves constructing the JSON-LD script and then embedding it into your website. Here is a general process:

1. Identify relevant schema types

Determine which schema types are most appropriate for the content on your page. For example, a blog post about a new recipe would likely use Recipe and potentially Article and Review (if ratings are present). A product page would use Product and AggregateRating.

2. Gather necessary data

Collect all the information required by the chosen schema type. For a Product schema, this would include the product name, description, image URL, price, currency, availability, and specific URLs for review pages.

3. Generate the JSON-LD script

You can write the JSON-LD script manually or use a schema generator. Manually writing the script offers full control.

Here is an example structure for a Product schema:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "LemRank SEO Tool",
  "image": "https://www.lemrank.com/images/lemrank-logo.png",
  "description": "Comprehensive SEO and rank-tracking platform.",
  "sku": "LR001",
  "brand": {
    "@type": "Brand",
    "name": "LemRank"
  },
  "offers": {
    "@type": "Offer",
    "url": "https://www.lemrank.com/pricing",
    "priceCurrency": "USD",
    "price": "99.00",
    "priceValidUntil": "2026-12-31",
    "itemCondition": "https://schema.org/NewCondition",
    "availability": "https://schema.org/InStock",
    "seller": {
      "@type": "Organization",
      "name": "LemRank Inc."
    }
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "reviewCount": "125"
  }
}
</script>

4. Embed the script on your page

Place the generated JSON-LD script within the <head> section of your HTML document. While it can also be placed in the <body>, placing it in the <head> is generally preferred for consistency and efficient parsing by search engines.

If you are using a Content Management System (CMS) like WordPress, there are often plugins available (e.g., Yoast SEO, Rank Math) that can help you add schema markup without directly editing code. These plugins often have settings where you can input the necessary data, and they will generate and embed the JSON-LD for you.

Testing schema before publishing

Before deploying schema markup to a live website, it is crucial to test it for correctness and to ensure it is eligible for rich results. Improperly implemented schema can be ignored by search engines or, in some cases, lead to manual penalties if it violates Google's guidelines.

The primary tool for testing schema markup is Google's Rich Results Test. This tool allows you to:

1. Enter a URL: Provide the URL of a page that has existing schema markup. The tool will fetch the page and analyze its structured data.
2. Paste code: Directly paste your JSON-LD, Microdata, or RDFa code snippet into the tool for analysis before it is live on a page.

The Rich Results Test will then report:

• Valid items: Which schema types were successfully identified and parsed.
• Rich result eligibility: Whether the identified schema is eligible to generate specific rich result types (e.g., "Product rich result," "FAQ rich result").
• Warnings and errors: Any issues that might prevent the schema from being fully understood or from appearing as a rich result. Warnings suggest areas for improvement, while errors indicate critical problems that must be fixed.

LemRank's Schema Validator also offers a robust testing solution. It not only checks for schema.org validity, ensuring your markup adheres to the schema.org vocabulary and structure, but also specifically tests for Google rich-result eligibility. This dual-check helps ensure that your structured data is technically correct and optimized for display in Google Search.

Regularly testing your schema, especially after making changes to your website or updating your schema implementation, helps maintain optimal search engine performance.

Common schema mistakes

Implementing schema markup effectively requires attention to detail. Several common mistakes can prevent structured data from being correctly parsed or from yielding rich results.

• Missing required properties: Each schema type has properties that are mandatory for it to be valid and eligible for rich results. For example, a Product schema requires name, image, and offers. Omitting these will cause errors. Always consult the schema.org documentation and Google's developer guidelines for specific type requirements.
• Incorrect data types: Using the wrong data type for a property can devalidate schema. For instance, price expects a numeric value, not text like "call for price." aggregateRating requires ratingValue to be a number, and reviewCount to be an integer.
• Inconsistent data: The information provided in the schema markup should accurately reflect the visible content on the page. If the price in your schema is different from the price displayed on the page, Google may ignore the schema or, in severe cases, issue a manual penalty.
• Markup hidden content: Do not use schema markup to describe content that is not visible to users on the page. Google's guidelines explicitly state that structured data should be a true representation of the page's content, and marking up hidden text is a violation.
• Using outdated schema vocabulary: While schema.org is generally backward compatible, using deprecated properties or classes might limit the effectiveness of your schema. Stay updated with the latest versions and recommended practices.
• Syntax errors in JSON-LD: A single misplaced comma, bracket, or quotation mark can break the entire JSON-LD script, making it unparseable. Tools like Google's Rich Results Test or LemRank's Schema Validator are essential for catching these errors.
• Unnecessary implementation: While schema is beneficial, not every piece of content needs extensive markup. Focus on the schema types that are most relevant to your content and have the greatest potential for rich results (as discussed in "The 8 schema types with the biggest SEO impact"). Over-markup can lead to clutter and maintenance issues without providing additional SEO benefit.
• Not testing thoroughly: As highlighted in the "Testing schema before publishing" section, failing to test your schema with tools like Google's Rich Results Test or LemRank's Schema Validator often leads to issues only discovered after deployment, potentially delaying the appearance of rich results.

Related

• How to Use the Schema Validator
• How to Target Featured Snippets