How do we make better SEO with schema.org?

What is Schema.org?

Schema.org is a collaborative, community-driven initiative that provides a collection of structured data schemas for marking up web pages. It's a vocabulary, a shared understanding of the language search engines like Google, Bing, Yahoo, and Yandex use to better understand the content on your website. Think of it as a translator, helping you speak directly to search engines about the meaning of your content, not just the words on the page. It was launched in 2011 by these major search engines to create a unified schema vocabulary that webmasters could use to improve search engine understanding of their websites.

The goal of schema.org is to provide a standardized vocabulary for describing entities and their properties. These entities can be anything from local businesses and products to events, reviews, articles, and even people. By using schema.org vocabulary, you provide search engines with explicit clues about the meaning of your content, helping them to categorize, index, and display your web pages more effectively in search results.

How Schema.org Improves SEO

Schema.org markup enhances your SEO in several important ways:

• Enhanced Rich Snippets: One of the most direct benefits of using schema.org is the ability to generate rich snippets in search results. Rich snippets are the enhanced descriptions that appear below the title tag in search engine results pages (SERPs). These can include things like star ratings for reviews, price information for products, event dates and locations, and much more. Rich snippets make your listings more visually appealing and informative, leading to higher click-through rates (CTR). A higher CTR signals to search engines that your content is relevant and valuable, which can indirectly improve your rankings.
• Improved Search Engine Understanding: Schema.org helps search engines understand the context of your content. Instead of just trying to decipher the meaning from the text on your page, search engines can rely on the structured data you provide. This allows them to accurately classify your content and match it with relevant search queries. For example, if you mark up a recipe using schema.org, search engines can easily identify the ingredients, cooking time, and nutritional information. This understanding allows them to display your recipe in relevant searches and even provide voice search answers to users.
• Better Knowledge Graph Integration: Search engines use knowledge graphs to organize and connect information about the world. Schema.org markup helps search engines understand the entities and relationships described on your website, allowing them to integrate your content into their knowledge graph. This can lead to your brand or website appearing in knowledge panels in search results, further increasing visibility and authority.
• Voice Search Optimization: As voice search becomes increasingly popular, structured data becomes even more critical. Voice assistants rely on structured data to understand the context of search queries and provide accurate, concise answers. By implementing schema.org markup, you can improve your chances of having your content featured in voice search results.
• Local SEO Boost: Schema.org is particularly beneficial for local businesses. By marking up your business information with schema.org vocabulary, you can help search engines accurately display your business name, address, phone number (NAP), hours of operation, and other important details in local search results. This can improve your visibility in local search and help customers find your business more easily.

Implementing Schema.org

Implementing schema.org involves adding structured data markup to your website's HTML code. There are several ways to do this:

• JSON-LD (JavaScript Object Notation for Linked Data): This is the recommended method by Google. It involves embedding a JSON-LD script within the or of your HTML code. JSON-LD is easy to implement and maintain because it separates the structured data from the visual content of your page.
• Microdata: This method involves adding schema.org attributes directly to your HTML elements. While effective, it can be more cumbersome to implement than JSON-LD, as it requires modifying the HTML structure of your page.
• RDFa (Resource Description Framework in Attributes): Similar to Microdata, RDFa also involves adding attributes to your HTML elements. While RDFa is more flexible than Microdata, it can also be more complex to implement.

Steps to Implement Schema.org:

1. Identify the Schema Types: Determine the most relevant schema types for your content. Schema.org offers a wide range of types, from "Product" and "Event" to "Article" and "Organization." Choose the types that best describe the entities and properties on your web page.
2. Gather Your Data: Collect all the necessary information for the schema properties you've chosen. This may include product names, prices, descriptions, dates, locations, reviews, and more.
3. Choose an Implementation Method: Select the implementation method that works best for you – JSON-LD, Microdata, or RDFa. JSON-LD is generally recommended for its ease of use.
4. Generate the Markup: Use a schema markup generator tool or manually create the structured data markup. There are many online tools available that can help you generate schema markup based on your input.
5. Add the Markup to Your Website: Paste the generated markup into the appropriate location in your website's HTML code. For JSON-LD, place it within the or of your page. For Microdata and RDFa, add the attributes directly to the corresponding HTML elements.
6. Test Your Markup: Use Google's Rich Results Test tool to validate your schema markup. This tool will identify any errors or warnings in your implementation and help you ensure that your markup is correctly formatted. The schema validator available at validator.schema.org can also be helpful.
7. Monitor Your Results: Track your website's performance in search results after implementing schema.org markup. Monitor your click-through rates, rankings, and organic traffic to assess the impact of your changes.

HTML code example incorporating schema.org vocabulary for a simple webpage representing a recipe:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Amazing Chocolate Chip Cookies</title>
  <meta name="description" content="The best chocolate chip cookie recipe ever! Chewy, soft, and full of chocolate.">
</head>
<body>

  <div itemscope itemtype="http://schema.org/Recipe">

    <h1 itemprop="name">Amazing Chocolate Chip Cookies</h1>

    <img itemprop="image" src="chocolate-chip-cookies.jpg" alt="Freshly Baked Chocolate Chip Cookies">

    <p itemprop="description">These are the best chocolate chip cookies you'll ever make!  They're perfectly chewy, soft, and loaded with chocolate chips.</p>

    <p><strong>Prep Time:</strong> <time itemprop="prepTime" datetime="PT15M">15 minutes</time></p>
    <p><strong>Cook Time:</strong> <time itemprop="cookTime" datetime="PT12M">12 minutes</time></p>

    <p><strong>Total Time:</strong> <time itemprop="totalTime" datetime="PT27M">27 minutes</time></p>

    <p><strong>Yield:</strong> <span itemprop="recipeYield">2 dozen cookies</span></p>

    <h2>Ingredients</h2>
    <ul itemprop="recipeIngredient">
      <li>1 cup (2 sticks) unsalted butter, softened</li>
      <li>¾ cup granulated sugar</li>
      <li>¾ cup packed brown sugar</li>
      <li>1 teaspoon vanilla extract</li>
      <li>2 large eggs</li>
      <li>2 ¼ cups all-purpose flour</li>
      <li>1 teaspoon baking soda</li>
      <li>1 teaspoon salt</li>
      <li>2 cups chocolate chips</li>
    </ul>

    <h2>Instructions</h2>
    <ol itemprop="recipeInstructions">
      <li>Preheat oven to 375°F (190°C).</li>
      <li>In a large bowl, cream together the butter, granulated sugar, and brown sugar until light and fluffy.</li>
      <li>Beat in the vanilla extract and then the eggs, one at a time.</li>
      <li>In a separate bowl, whisk together the flour, baking soda, and salt.</li>
      <li>Gradually add the dry ingredients to the wet ingredients, mixing until just combined.</li>
      <li>Stir in the chocolate chips.</li>
      <li>Drop by rounded tablespoons onto ungreased baking sheets.</li>
      <li>Bake for 9-11 minutes, or until golden brown.</li>
      <li>Let cool on baking sheets for a few minutes before transferring to a wire rack to cool completely.</li>
    </ol>

     <p><strong>Author:</strong> <span itemprop="author" itemscope itemtype="http://schema.org/Person">
        <span itemprop="name">Jane Doe</span>
      </span></p>

     <p><strong>Keywords:</strong> <span itemprop="keywords">chocolate chip cookies, cookies, dessert, baking</span></p>

  </div>

</body>
</html>

Key improvements and explanations:

• itemscope and itemtype: These are the foundational attributes. itemscope signals the start of a schema.org item (in this case, a Recipe). itemtype specifies the type of thing this item represents, using a URL from schema.org. Crucially, place the itemscope and itemtype on the outermost element that encompasses all the properties you want to describe. This allows search engines to understand the entire block as a single entity. I put it on a div that wraps the whole recipe.

• itemprop: This attribute specifies a property of the item. For example, itemprop="name" tells the search engine that the content within the

  tag is the name of the recipe. itemprop="description" provides the description.

• Specific Properties: I've used a variety of common Recipe properties, including:
  • name: The name of the recipe.
  • image: A URL pointing to an image of the recipe. It's very important to have an alt attribute on the tag for accessibility.
  • description: A brief description of the recipe.
  • prepTime, cookTime, totalTime: These are durations, and you must use ISO 8601 duration format (e.g., "PT15M" for 15 minutes, "PT1H30M" for 1 hour and 30 minutes). Use the tag. The datetime attribute is required for schema.org to correctly interpret the duration.
  • recipeYield: The number of servings or the amount the recipe makes.
  • recipeIngredient: A list of ingredients. Each ingredient should be listed individually, and ideally, you'd provide even more structured data about each ingredient (quantity, unit, etc.), but a simple list of strings is a good starting point. Note that I put the itemprop on the

    • recipeInstructions: The steps to make the recipe. Ideally, each step would be wrapped in a separate

      with itemprop="step", but for simplicity, I've put itemprop on the

      1. author: Uses nested schema for a Person. This allows describing the author in more detail if needed.
      2. keywords: Comma-separated list of keywords.
  • Nesting Schema: The author uses nested schema. The itemscope and itemtype define a Person within the recipe's author property. This enables more detailed information about the author to be provided (e.g., name, URL, etc.).
  • Valid HTML: The code is valid HTML.
  • SEO Benefits: While schema.org doesn't directly guarantee higher rankings, it helps search engines understand the meaning of your content, which can lead to rich snippets in search results (e.g., a recipe carousel), improved visibility, and higher click-through rates.
  • Image Importance: A good, clear image with an informative alt tag is crucial for schema markup, particularly for recipes.
• Enter the URL of your page (if it's live on the web) or paste the HTML code directly into the tool.
• The tool will analyze the page and tell you if the schema markup is valid and if Google can generate rich results from it. It will also show you a preview of how the rich results might look.
• Accuracy: Make sure the data you provide in your schema markup is accurate and consistent with the content on your page. Don't try to "game" the system by providing misleading information.
• Relevance: Use the most specific schema types that are relevant to your content. For example, if you're marking up a product, use the Product schema type instead of a more general type like Thing.
• Completeness: Provide as much information as possible using schema properties. The more information you provide, the better search engines can understand your content.
• Dynamic Content: If your content is dynamically generated (e.g., from a database), make sure your schema markup is also dynamically generated to reflect the current content.
• JSON-LD (Alternative): While I've provided an example using microdata (inline HTML attributes), another common way to implement schema markup is using JSON-LD. JSON-LD is a block of JSON code that you embed in the section of your HTML. It's often preferred because it keeps the schema markup separate from the presentation of your content, making it easier to maintain. Google recommends using JSON-LD when possible.

Schema.org JSON-LD Examples: A Practical Guide

Schema.org is a collaborative initiative that provides a collection of standardized, machine-readable vocabularies (schemas) for describing data on the internet. JSON-LD (JavaScript Object Notation for Linked Data) is a lightweight JSON-based syntax used to implement schema.org vocabularies, making it easy for search engines to parse and understand your content.

Essential Schema.org Properties for Blog Posts

When marking up your blog posts, several key schema.org properties are particularly useful:

• @context: Specifies the vocabulary being used. Always set to https://schema.org.
• @type: Defines the type of content being described. For blog posts, this should be BlogPosting.
• headline: The title of the blog post.
• image: A representative image URL for the post.
• datePublished: The date the blog post was originally published in ISO 8601 format (e.g., 2023-10-27).
• dateModified: The date the blog post was last modified in ISO 8601 format.
• author: Information about the author of the blog post. Can be a Person or an Organization.
• publisher: Information about the publisher of the blog post (typically your website or organization). This also can be a Person or an Organization.
• description: A brief summary of the blog post content.
• mainEntityOfPage: Indicates the canonical URL of the page where the blog post is located.
• articleBody: The main content of the blog post. Note: While this can technically be used, it's generally not recommended to include the entire article body in the JSON-LD. Search engines prioritize the content visible on the page.

JSON-LD Example for a Blog Post

Here's a comprehensive example of a JSON-LD implementation for a blog post:

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "The Ultimate Guide to Schema.org for Bloggers",
  "image": [
    "https://example.com/images/schema-guide-featured.jpg"
   ],
  "datePublished": "2023-10-26",
  "dateModified": "2023-10-27",
  "author": {
    "@type": "Person",
    "name": "Jane Doe",
    "url": "https://example.com/about-jane-doe"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Example Blog",
    "logo": {
      "@type": "ImageObject",
      "url": "https://example.com/images/logo.png"
    }
  },
  "description": "Learn how to implement schema.org JSON-LD to boost your blog's search engine visibility.",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://example.com/blog/schema-org-guide"
  }
}

How do I validate the structured data

https://search.google.com/test/rich-results

Conclusion

Schema.org is a valuable tool for improving your website's SEO. By providing search engines with structured data, you can enhance your rich snippets, improve search engine understanding of your content, boost your local SEO, and prepare for the future of voice search. While implementing schema.org requires some technical effort, the potential benefits for your website's visibility and traffic are well worth the investment.