Understanding Schema Markup and Its Importance for SEO

  • June 23, 2024
  • SEO
No Comments

Schema.org is a comprehensive collection of vocabulary (or schemas) that is utilized to apply structured data markup to web pages and digital content. Correctly implementing schema can significantly enhance SEO performance by generating rich snippets in search results.

Structured data markup is understood and utilized by platforms such as Google and Microsoft to produce enhanced rich results (or rich snippets) on search engine results pages (SERPs) or in emails. For instance, markup your ecommerce product pages with the variants schema to aid Google in understanding product variations.

Schema.org is an independent initiative that has played a vital role in establishing a uniform approach to structured data across the internet. It commenced collaborative efforts with key search engines like Google, Yahoo, Bing, and Yandex as early as 2011.

The Schema vocabulary can be integrated into web pages through various encoding formats such as RDFa, Microdata, and JSON-LD. Notably, JSON-LD schema is preferred by Google due to its simplicity in application and maintenance.

While schema itself is not a direct ranking factor, it makes your webpage eligible for rich snippets in SERPs, thereby enhancing search visibility and potentially increasing the click-through rate (CTR) from search results.

Furthermore, schema can be instrumental in constructing a knowledge graph of entities and topics. By employing semantic markup, you align your website with AI algorithms’ methods of categorizing entities, assisting search engines in comprehending your site’s context and content better.

This enhanced comprehension by search engines translates to additional information helping them interpret the subject of your webpage accurately.

You can also establish explicit connections by linking your entities directly to external sites like Wikipedia or Google’s knowledge graph, which can yield positive SEO results. As Martha van Berkel, CEO of Schema App, suggests, such strategies help search engines conserve resources (especially crucial for large websites with millions of pages) and increase the likelihood of correct content interpretation and ranking.

These advantages, although indirect, support your SEO efforts by providing search engines with the best chance to interpret your content correctly, thereby offering users the best chances of discovering it.

Outlined above are some of the most widely recognized uses of schema, supported by Google and other search engines.

It is important to note that certain object types might have a schema.org definition but lack current search engine support.

In such scenarios, it is advisable to implement them nonetheless, as future support by search engines could provide a head start, leveraging already-existing implementations.

Google endorses JSON-LD as the preferred format for structured data. While Microdata remains supported, JSON-LD is recommended due to its easier application.

However, specific technical constraints, such as outdated content management systems, might hinder the implementation of JSON-LD schema. In these cases, marking up HTML using Microdata or RDFa becomes the only viable option.

Google now permits mixing JSON-LD and Microdata formats by matching the @id attribute of JSON-LD schema with the itemid attribute of Microdata schema. This strategy helps reduce the HTML size of your pages.

For instance, in an FAQ section with extensive text, you might use Microdata for the content and JSON-LD for the structured data, avoiding text duplication and preventing an increase in page size. We will explore this further below in the article when we discuss each type in detail.

JSON-LD encodes data using JSON, making it straightforward to integrate structured data into web pages. JSON-LD allows the connection of different schema types using a graph with @ids, improving data integration and reducing redundancy.

Consider an example. Suppose you operate a store offering high-quality routers. When you inspect the source code of your homepage, you might find data specific to your business spread between two

tags.

The following JSON-LD formatted code illustrates the markup for that section, which can be included within your webpage’s

section:

This snippet defines your business as a store through the attribute "@type": "Store".

It subsequently details its location, contact information, operating hours from Monday to Saturday, and different hours for Sunday.

By structuring your webpage data this way, you offer crucial information directly to search engines, improving their ability to index and display your site accurately in search results. As with initial HTML tags, integrating this JSON-LD script allows search engines to understand specific aspects of your business.

Here’s another example. Let’s review a WebPage schema connected with Organization and Author schemas via @id. JSON-LD, the format Google recommends, is preferred due to its extreme flexibility, exemplified as follows:

This schema example includes:

  • The Website schema referencing the organization as the publisher using @id.
  • The Organization entity described with comprehensive properties.
  • The WebPage schema linking back to the Website through isPartOf.
  • The NewsArticle schema connecting back to the WebPage using isPartOf and linking the author attribute via @id.

By tagging graph nodes with "@id" attributes, we explicitly inform Google about the interconnectedness of various schema types.

It’s important to note that adding custom hashes (#) provides extra safety against accidental repeatability of schema IDs. Although not mandatory, it serves as an additional layer of assurance.

You might question the necessity of utilizing "@id" for node connections rather than dropping schemas for organization, author, and webpage on one page independently. Explicit linking with @id is vital because Google and other search engines cannot consistently interpret these connections without it.

Integrating more schema types into the graph is seamless, much like building with Lego bricks. For instance, adding an image schema would look as follows:

{
   "@type": "ImageObject",
   "@id": "https://www.example.com/#post-image",
   "url": "https://www.example.com/example.png",
   "contentUrl": "https://www.example.com/example.png",
   "width": 2160,
   "height": 1215,
   "thumbnail": [
     {
        "@type": "ImageObject",
        "url": "https://example.com/4x3/photo.jpg",
        "width": 1620,
        "height": 1215
      },
      {
        "@type": "ImageObject",
        "url": "https://example.com/16x9/photo.jpg",
        "width": 1440,
        "height": 810
      },
      {
        "@type": "ImageObject",
        "url": "https://example.com/1x1/photo.jpg",
        "width": 1000,
        "height": 1000
      }
    ]
}

To integrate this within the schema graph, simply add it as a parent node and link it via @id:


        
				

More from our blog

See all posts