SEO
March 21, 2024
SEOs have been talking about structured data for several years now – ever since Google, Bing, Yahoo!, and Yandex came together in 2011 to create a standardized list of attributes and entities that they all agreed to support, known as Schema.org.
However, there is still a lot of confusion and lack of understanding around what structured data is, what its purpose is, and how and when to properly implement it for SEO purposes.
A survey conducted last year by Bing found that only 17% of marketers are using (or were planning to use) Schema.org structured data markup.
Despite it being around for a while, structured data seems to still be a confusing concept for many. The value it can provide is clear – by more effectively labeling and organizing the data on your website, you enable search engines to better comprehend the content and potentially display it in richer, more useful ways in the search results.
However, the specifics of what structured data entails and how to take advantage of it remain murky for a lot of SEOs and marketers.
This lack of widespread adoption is likely due to a combination of factors – the technical implementation required, uncertainty around following the proper markup standards, questions about when structured data is worthwhile to use, and more.
Structured data is any data that is organized in a clear, labeled format – just like taking a bunch of scattered notes and compiling them into a structured table with labeled rows and columns. On the web, structured data involves using standardized markups and vocabularies to label different elements and types of content on your web pages.
Racheal Called, confirmed 5 PM meet at coffee shop, Friday
John called, confirmed meeting confirmed for SEO, 10 AM office
The same data can be presented in a structured form.
While structured data can take many forms like Open Graph markup or database schemas, from an SEO perspective it typically refers to implementing specific code standards on webpages. The purpose is to provide additional descriptive details about the content in a format that search engines can clearly understand.
This structured data markup enhances search engines’ comprehension of the page’s subject matter and elements. As a result, it aids with relevancy signals for rankings and unlocks opportunities for enriched search listings like rich snippets, knowledge panels, carousels and more.
However, since this markup needs to make sense to both search bots and humans, there are standardized implementation methods (called syntaxes) and defined categorizations of concepts/relationships (called vocabularies) that should be adhered to.
The most common syntaxes are Microdata, JSON-LD, and microformats. These act as the “languages” for writing the descriptive markup. As for vocabularies that define the terminology, the two main ones are Schema.org and Microformats.org. Schema.org works with Microdata and JSON-LD syntaxes, while microformats use their own paired vocabulary.
You may also come across references to RDFa, which is another syntax option, but the ones mentioned are the primary standards used for structured data markup in an SEO context. The key is using the proper syntax and vocabulary combinations that major search engines can understand.
Search engines leverage structured data to categorize and index web pages with greater accuracy. This allows them to display that content in a more enhanced, tailored way within the search results.
With structured data markup, search engine crawlers can clearly identify the specific nature of different page elements like products, events, and so on. This allows the engines to connect those components to relevant search queries and better understand the overall relevance of the page.
Essentially, structured data acts as a direct line of communication between a website’s content and the search engine’s indexing system. It provides additional context that helps guide improved SEO performance and visibility.
The structured data tells the search engine things like “this snippet represents an event” or “those details are for a product listing.” The engine can then opt to generate enriched search listings and displays based on those identified entities and data types.
This could manifest as rich results highlighted with star ratings, pricing info, event times, and other supplementary details pulled directly from the structured data. These enhanced listings tend to be more eye-catching and useful for users, resulting in higher click-through rates from the search results pages.
The Schema.org vocabulary is structured in a hierarchical manner, starting from the most broad, generic category of “Thing.” Under this umbrella term, there are several high-level types that a “Thing” can fall into, such as:
These represent the broadest classifications or categories that an item can belong to within the Schema.org structure. From each of these top-level types, you can then drill down further into more specific subcategories.
For instance, let’s look at the “Event” type. If we expand that category in Schema.org’s full hierarchy list, we’ll see various sub-types of events laid out, such as:
So within this “Event” parent category, you have many more granular event types to choose from based on the specific kind of event you’re marking up.
The next level of detail comes from the “Properties” defined for each type. These properties allow you to provide those rich descriptive details that search engines may then utilize to enhance your listings in the results pages. They help make your structured data markup more visually compelling and informative.
For example, if you select the “ComedyEvent” type from that list, you’ll be shown all of the available properties and fields where you can supply information like event descriptions, performer details, pricing, and so on. It’s this combination of selecting the appropriate type and populating the relevant properties that unlock those rich result opportunities.
(source: schema.org)
The Schema.org structure goes even deeper than just the types and properties. For certain properties, you can drill down one more level to access more granular specifications.
Take the “Audience” property as an example – if you select that under a given schema type’s properties, it will expand to show additional details like:
To ensure search engines can fully comprehend your structured data and increase your chances of triggering those coveted enriched listings, it’s important to apply these best practices:
Proper implementation is key when it comes to structured data. Even if you have the markup coded perfectly, if it’s placed in the wrong location on your website’s pages, search engines may not be able to detect and parse it effectively.
The recommended best practice is to insert your JSON-LD structured data markup into the <head> section of the page’s HTML. By including it in the <head>, you ensure it gets parsed early and avoids any potential conflicts with other page elements.
Here’s an example of what properly positioning your JSON-LD might look like:
<!DOCTYPE html>
<html lang="en">
<head>
<title>Event Page</title>
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Event",
"name": "Annual Baking Conference",
"startDate": "2024-05-21T08:00",
"endDate": "2024-05-24",
"eventAttendanceMode": "https://schema.org/OfflinePermanently",
"eventStatus": "https://schema.org/EventScheduled",
"location": {
"@type": "Place",
"name": "Seattle Convention Center",
….. (remaining structured code)
}
</script>
</head>
<body>
<!-- Page content here -->
</body>
</html>
Proper implementation is key when it comes to structured data. Even if you have the markup coded perfectly, if it’s placed in the wrong location on your website’s pages, search engines may not be able to detect and parse it effectively.
In this JSON-LD example for an Event schema type, you can see the structured data is enclosed in <script> tags within the <head> portion of the HTML. This is the recommended placement for proper parsing by search engine crawlers.
Putting your JSON-LD markup in this location ensures it gets picked up efficiently without conflicts and increases your chances of having those rich event details displayed prominently in search features and listings.
After adding structured data markup to your website pages, it’s crucial to test and validate your implementation. This ensures search engines can properly parse and understand the structured data without any errors.
Google provides a handy tool called the URL Inspection Tool that allows you to analyze how they view and process a specific page’s structured data. Simply input the URL, and the tool will scan the page, providing detailed insights.
The URL Inspection Tool will report the number of valid structured data items it detects on that page. It also describes each item, so you can verify the markup accurately representing the intended content types and details.
Perhaps most valuably, the tool surfaces any warnings or errors related to the structured data implementation. These could include markup mistakes, missing fields, or other issues preventing search engines from fully comprehending the structured data as intended.
With this feedback, you can promptly troubleshoot and fix any errors, ensuring your structured data adheres to Google’s guidelines for rich result opportunities.
Currently, the URL Inspection Tool supports analysis for 17 different rich result types. However, Google notes there may be additional valid rich types on pages that don’t yet have specific testing in this tool. But overall, it provides comprehensive validation for the majority of structured data markup.
After using the URL Inspection Tool to identify and fix any structured data errors or warnings on your page, the next step is to request Google to recrawl and reindex that webpage.
This allows Google’s systems to re-evaluate the page and process the corrected structured data markup you’ve implemented. Without this recrawl request, it could take weeks or months before Google naturally re-visits and detects your changes.
To expedite getting your revised structured data parsed, you’ll want to proactively notify Google that the page is ready for another crawl by submitting it through Google Search Console:
Google will then add that URL to its crawling queue to be processed. However, keep in mind that despite requesting indexing, it can still take anywhere from a few days to a couple of weeks before the recrawl occurs and your updated structured data goes live.
So once you’ve thoroughly tested your markup and resolved any lingering issues, don’t forget this crucial re-indexing step.
On the surface, implementing structured data may seem a very technical task, especially if you’re not well-versed in HTML and website coding. However, the teams at Google and Schema.org have made admirable efforts to make this process easy and accessible to all.
Although structured data is not a direct influencer on keyword rankings, like the other factors including link-building. It still would improve the website rankings in the long term.
Through detailed documentation, sample code snippets ready for adaptation, and dedicated testing tools, there are resources available to guide even a beginner through properly marking up their websites. You don’t need to be a coding expert to tap into the power of structured data.
By leveraging structured data for SEO effectively, you can communicate key details that both capture user attention and provide a richer, more robust search experience.
