Structured data is a standardized format of code that helps search engines understand the content of a page. While it is invisible to the end-user, it serves as a “translator” for search engine bots.
For example, imagine a cooking blog. A human reader can easily recognize a recipe: they see a list of ingredients, cooking steps, prep time, and a photo of the finished dish.
Search engines, however, are not human. They need help to decipher that this text is specifically a recipe and not just a random list of words. Structured data labels these constituent parts, tagging the text specifically as “ingredients,” “cook time,” or “calories.”
In SEO circles, “Structured Data” and “Schema Markup” are often used interchangeably. To be precise:
-
Structured Data is the general method of organizing data.
-
Schema.org is the specific vocabulary (language) used by major search engines (Google, Bing, Yahoo, Yandex) to understand that data.
Table of Contents
Types of structured data formats
While there are hundreds of Schema types available, not all are supported by Google for rich results. You should always check the Google Search Gallery to see which types are eligible for special display features.
To implement this data, there are three main formats:
1. JSON-LD (The Gold Standard)
JSON-LD (JavaScript Object Notation for Linked Data) is Google’s recommended format.
-
How it works: It uses a JavaScript script tag to insert the data.
-
Why it’s better: It sits separately from your page’s visible HTML (usually in the
<head>or body), making it much easier to implement and maintain without breaking your site’s design. -
Compatibility: Both Google and Bing fully support JSON-LD.
2. Microdata
Microdata was the old standard. It involves nesting metadata within the existing HTML content of a page.
-
How it works: You add attributes like
itempropdirectly to your<div>and<span>tags. -
The downside: It is messier to manage. If you change your page design or HTML structure, you often break the structured data in the process.
3. RDFa
RDFa (Resource Description Framework in Attributes) is an HTML5 extension that supports linked data.
-
How it works: Similar to Microdata, it uses HTML tag attributes to label content.
-
The downside: Like Microdata, it requires implementation directly into the HTML, making it more complex to implement than JSON-LD.
The 3 core SEO benefits for structured data
Why go through the trouble of adding this code?
1. Win Rich Snippets (SERP Features)
This is the most visible benefit. Structured data makes your page eligible for Rich Results (formerly Rich Snippets). These include star ratings, recipe cards, event listings, FAQ dropdowns, and carousels. These visual enhancements make your result pop, typically leading to a significantly higher Rata de click (CTR).
2. Improve relevance & understanding
While Google has stated that structured data is not a direct ranking factor, it is a massive relevancy signal. By explicitly telling Google, “This is a product, this is the price, and this is the review,” you help the algorithm match your content to the right user queries with high precision.
3. Dominate Voice Search
Voice assistants (like Google Assistant, Siri, and Alexa) rely heavily on structured data. When a user asks a question, the device often reads the answer from a “Featured Snippet” or “Position Zero” result. Structured data is often the key to securing that spot.
How to implement structured data
There’s a variety of different ways to implement structured data. It can be hard-coded, generated dynamically using JavaScript, or injected with GTM. You can format it using JSON-LD, Microdata or RFDa,
although JSON-LD is the recommended format, and the one most commonly used because it doesn’t require any alterations to the HTML on a page.
However, Bing doesn’t support JSON-LD yet, so consider how important Bing’s support for your structured data might be for your site. Each type of structured data has a certain number of required and recommended attributes.
These attributes should be visible on the page in order to be valid in structured data, so first check that all of the attributes you wish to include are somewhere on the page. You can find a full specifications for each type of structured data here.
JSON-LD
JSON-LD structured data can sit in the or sections of your page (most commonly it’s included in the ) and doesn’t need to affect the HTML on the page. Simply in paste the following snippet.
<script type=”application/ld+json”>
{
“@context”: “https://schema.org”,
“@type”: “Organization”,
“address”: {
“@type”: “PostalAddress”,
“addressLocality”: “Paris, France”,
“postalCode”: “F-75002”,
“streetAddress”: “38 avenue de l’Opera”
},
“email”: “secretariat(at)google.org”,
“faxNumber”: “( 33 1) 42 68 53 01”,
“member”: [
{
“@type”: “Organization”
},
{
“@type”: “Organization”
}
],
“alumni”: [
{
“@type”: “Person”,
“name”: “Jack Dan”
},
{
“@type”: “Person”,
“name”: “John Smith”
}
],
“name”: “Google.org (GOOG)”,
“telephone”: “( 33 1) 42 68 53 00”
}
</script>
Microdata
Microdata uses in-line descriptions within meta tags to identify elements as structured data attributes. For this, we need to identify each of the attributes in our existing code to mark up. Here is an example of Microdata markup:
<div itemscope itemtype="”https://schema.org/Organization”">
<span itemprop="”name”">Google.org (GOOG)</span>
Contact Details:
<div itemprop="”address”" itemscope itemtype="”https://schema.org/PostalAddress”">
Main address:
<span itemprop="”streetAddress”">38 avenue de l’Opera</span>
<span itemprop="”postalCode”">F-75002</span>
<span itemprop="”addressLocality”">Paris, France</span>
,
</div>
Tel:<span itemprop="”telephone”">( 33 1) 42 68 53 00 </span>,
Fax:<span itemprop="”faxNumber”">( 33 1) 42 68 53 01 </span>,
E-mail: <span itemprop="”email”">secretariat(at)google.org</span>
Members:
– National Scientific Members in 100 countries and territories: Country1, Country2, …
– Scientific Union Members, 30 organizations listed in this Yearbook:
List of Alumni:
<span itemprop="”alumni”" itemscope itemtype="”https://schema.org/Person”">
<span itemprop="”name”">Jack Dan</span>
</span>,
<span itemprop="”alumni”" itemscope itemtype="”https://schema.org/Person”">
<span itemprop="”name”">John Smith</span>
</span>,
History:
</div>
RDFa
RDFa is really similar to Microdata. Again, this is done inline within the HTML, so you need to start by identifying each element you want to markup in your page’s code, and then add the structured data within its meta tags. RFDa has a slightly different syntax to Microdata – your markup should look something like this:
<div vocab="”https://schema.org/”" typeof="”Organization”">
<span property="”name”">Google.org (GOOG)</span>
Contact Details:
<div property="”address”" typeof="”PostalAddress”">
Main address:
<span property="”streetAddress”">38 avenue de l’Opera</span>
<span property="”postalCode”">F-75002</span>
<span property="”addressLocality”">Paris, France</span>
,
</div>
Tel:<span property="”telephone”">( 33 1) 42 68 53 00 </span>,
Fax:<span property="”faxNumber”">( 33 1) 42 68 53 01 </span>,
E-mail: <span property="”email”">secretariat(at)google.org</span>
Members:
– National Scientific Members in 100 countries and territories: Country1, Country2, …
– Scientific Union Members, 30 organizations listed in this Yearbook:
List of Alumni:
<span property="”alumni”" typeof="”Person”">
<span property="”name”">Jack Dan</span>
</span>,
<span property="”alumni”" typeof="”Person”">
<span property="”name”">John Smith</span>
</span>
History:
</div>
Pro Tip: If you inject schema using JavaScript or Google Tag Manager, simple code validators might miss it. Instead, use the URL Inspection Tool inside Google Search Console. Click "Test Live URL" and then "View Tested Page" to see the actual HTML Google rendered—this confirms if they are successfully "seeing" your code.
Testing your structured data
Now you’ve added your structured data, it’s time to test that it’s valid. Simply paste your code or URL into the Rich Results Test Tool and it will give your results.
If you’re dynamically generating your Structured Data with JavaScript, or using GTM, you may need to paste in your rendered code rather than a URL (we find that sometimes the tool doesn’t pick up dynamically inserted Structured Data, even if it’s valid).
You can either load your page up in the browser and copy the source code or use the ‘Inspect URL’ tool in Google Search Console and ‘Test Live URL’. Click ‘View Tested Page’, which will show you the HTML that Google has rendered. Copy this into the Structured Data Testing Tool, and your Structured Data should be picked up.