Structured Data

Structured data (also referred to as schema markup), is one of the cornerstones of technical SEO. It’s also one of the more intimidating elements of SEO as it requires some technical knowledge, but in reality, it’s not that bad at all.

Outside of SEO, structured data is a term that describes data that is organised in a certain format. In the field of Computer Science, structured data is at the core of relational databases and SQL (StructureIn this chapter, we’ll cover the fundamentals of structured data such as what it is and why it’s important for Google and SEO in general. We’ll also look at the various different types of schema markup before finally walking you through how to implement structured data on your website.d Query Language).

Classifications of Structured Data

What Is Structured Data?

Google’s understanding of the content on a page has drastically improved over the years, however, when it comes to understanding the specific meaning of a page, it needs a little help.

This is where structured data, which was put together by Google, Bing and Yahoo! and Yandex in 2011, comes into play.

Structured data is information that is formatted into a repository to allow webmasters to provide useful information about a web page and classify the content of the page so that search engine crawlers can understand it better.

For example, if you have a recipe page, it’s easy for humans to identify important information such as the:

However, search engines have to work much harder in order to figure out what this data actually means.

Therefore, by marking up the above information using structured data, Google is able to read and understand exactly what is on the page. This in turn, allows for a richer search experience for users.

Let’s look at how structured data is formatted.

Schema.org

Schema.org is the vocabulary that is used for structured data; it’s the language search engine crawlers use to understand what’s on your web page. Schema.org is the most commonly used vocabulary for marking up web pages, but there are other formats too such as Microformats.org which is often used for marking up product reviews or outlining physical locations.

Essentially, Schema.org is a library of “things” that can be defined on the Internet.

For example, there is specific syntax to notate the important information about a recipe, i.e. cooking time, ingredients etc.

Here’s a sneak peak of how a recipe page might appear in the search results if you mark it up using the above notation.

You can see that Google displays information such as the cooking time, ingredients and calorie count in addition to the generic page title, meta description and URL for this recipe directly within the results page.

This is what we meant when we said structured data helps provide a “richer” experience for the user.

Types of Schema Markups

There’s a shema for just about anything you can think of – from movies and books to reviews and events.

Below, we have listed some of the popular uses of schema:

Each type of schema markup has various properties that are mandatory in order for it to work correctly. There are also additional properties that you can include if they are relevant and applicable to your case.

For example, for a recipe page, you may include the following properties:

The Code: Microdata vs RDFa vs JSON-LD

There are three main ways to format your structured data: microdata, RDFa and JSON-LD.

Microdata

Microdata is an HTML specification which extends HTML5 and uses HTML tag attributes to define the different properties that you want to expose as your structured data. Microdata is mostly deprecated but it’s worth being familiar with.

Here’s an example of what Microdata code would look like:

<div itemscope>
<p>My name is <span itemprop="name">George</span>.</p>
<p>My favorite band is called <span itemprop="band">Bon Iver</span>.</p>
 	<p>I live in <span itemprop="country">England</span>.</p>
</div>

RDFa

RDFa (or Resource Description Framework in Attributes) is another HTML5 extension that allows you to link data with user-visible content through the use of HTML tag attributes.

RDFa is commonly used to mark up dynamic elements such as reviews.

Here’s an example of what RDFa code would look like:

<div xmlns:dc="http://purl.org/dc/elements/1.1/"
  about="https://www.example.com/books/Ready-Player-One">
  <span property="dc:title">Ready Player One</span>
  <span property="dc:creator">Ernest Cline</span>
</div>

JSON-LD

JSON-LD (JavaScript Object Notation for Linked Data) is the format that is recommended by Google. Instead of tagging each element individually within your content with a HTML tag, JSON-LD is embedded within a <script> tag within the head or body of your web page, where you can define the various properties in a single block of code.

This makes nesting data items much easier and cleaner to look at and read.

For example, you can nest the country of the address of a music venue of an event within the same block of code.

The great thing about JSON-LD is the fact that you can mark up this information without explicitly mentioning it within your content – i.e. even if you don’t include the calorie count within your main content, but include it as a property within your structured data, Google will still use that information.

Here’s an example of what JSON-LD code would look like:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "url": "https://www.susodigital.com",
  "name": "SUSO Digital",
  "contactPoint": {
    "@type": "ContactPoint",
    "telephone": "+1-111-555-2222",
    "contactType": "Support"
  }
}
</script>

As described in the Google patent “Storing semi-structured data”, JSON-LD is the format that Google focuses upon when it comes to structured data.

In the patent, Google describes a system that discovers factual information through structured data and answers search queries about these facts.

Here’s the official description of how the system works from the patent: “the system searches the locations in the encoded data item identified by the schema as storing values for the specified keys to identify encoded data items that store values for the specified keys that satisfy the requirements specified in the query”.

So, from our JSON-LD example above, the system would answer the query: “What is the phone number of SUSO Digital?” by identifying any encoded data items for “SUSO Digital” and extracting the relevant information for what the user is looking for, in this case, the telephone number.

Why is Structured Data Important for SEO?

Let us clear one thing up from the get go – structured data is not a ranking factor.

If you mark up your web pages there is no guarantee that your rankings will improve.

Google, Bing, Yahoo! and Yandex all got together in 2011 to launch Schema.org for one main reason – to make it easier for them to understand the web (and to make it easier for webmasters to help them achieve this).

Think of structured data as the content that you “write” for search engines as opposed to humans.

After all, if it’s easy for search engines to crawl your website, you’ll have a better chance of ranking.

In the How Google Works module, we dedicated an entire chapter to the various different types of search results that Google displays to users.

Although marking up your content won’t increase your chances of ranking higher in the SERPs, it will however give your web pages a better chance of appearing in ”richer” search results.

These are just a few examples of how structured data can help enhance how your web pages appear in the search results, you can find more here.

If you’re wondering why these SERP features are important, we highly recommend that you read our chapter on the Search Results Page, but the bottom line is that they help increase the likelihood of users clicking through to your website.

The more clicks you get, the more likely your rankings will increase – this is because Google also looks at user behaviour as a signal.

Here’s another (pretty important) reason why you’ll want to use structured data.

Structured data helps future-proof your website.

This is especially key considering that Google is continually moving towards presenting users with hyper-personalised and quick answers to their queries.

It is worth mentioning however, that marking up your content also won’t guarantee that you’ll immediately appear within the rich results mentioned above; it simply gives you a better chance.

Google explains it best:

“Using structured data enables a feature to be present, it does not guarantee that it will be present. The Google algorithm tailors search results to create what it thinks is the best search experience for a user, depending on many variables, including search history, location, and device type. In some cases it may determine that one feature is more appropriate than another, or even that a plain blue link is best.”

Implementing Structured Data

Now that you know what structured data is and why it’s beneficial for SEO, let’s take a look at how you can go about implementing it for your website.

Almost every business and website will have a logo, so let’s take a look at how you would go about implementing the “Logo” structured data. The code itself is also super simple and serves as a great starting point.

The Logo structured data allows you to specify which image Google Search should use as your business or website’s logo in the Search results as well as in the Knowledge Graph.

The Code

Simply paste the following code into the <head> section of your About Us page (recommended) or homepage and replace the URL with wherever your logo is stored.

<html>
  <head>
    <title>About Us</title>
    <script type="application/ld+json">
    {
      "@context": "https://schema.org",
      "@type": "Organization",
      "url": "https://www.example.com",
      "logo": "https://example.com/images/logo.jpg"
    }
    </script>
  </head>
  <body>
  </body>
</html>

Let’s break down the JSON-LD code.

For the “Logo” markup, Google Search recognises some of the properties of the “Organization” markup.

The following two properties must be included within the code for it to be eligible for Google to display it as a rich result (i.e. within the Knowledge Graph).

1. logo: the URL of your business’s logo. Note that the image must be a minimum of 112 x 112px, the URL must be crawlable and indexable by Google and the file type should either be in .jpg, .png, or .gif format.

2. url: this is the URL that is associated with your logo i.e. the URL to your homepage.

If either one of these properties is missing, Google will not consider displaying it as a rich result.

For those who may not be quite as comfortable working with code, Google has the Structured Data Markup Helper which is designed to help webmasters generate the structured data code.

Although the options are limited, it’s a great way to start marking up your website.
Simply enter the URL of the page you want to mark up, select the data type and hit “Start Tagging”.

In this case, we’re looking to add “Local Businesses” structured data to our About Us page.

On the next page, Google will display your web page on the left and the schema markup tool on the right.

To start tagging your data, highlight the text (or an image) that you want to mark up on the left panel.

For example, when we highlight a section of our address, Google displays the possible tags we can use in a pop up – in this case, we want to markup the Street Address.

After clicking on the desired tag, Google will update the panel on the right with the data item.

To markup an image, simply click on the image.

Repeat this process for all of the relevant items that you want to tag – we recommend marking up as much of the data items that Google displays.

Click “Create HTML” when you’ve finished adding tags.

On the next page, Google will display your structured data code on the right hand panel. Importantly, ensure that the code is in JSON-LD as opposed to microdata as this is the recommended format by Google.

Insert this code in the <head> section of your web page.

The Test

Once you’ve got your structured data code, you can test it using Google’s aptly titled Structured Data Testing Tool.

You can either input the URL of the web page that you implemented the structured data on, or the code itself.

Simply hit “Run Test” and Google will do the rest.

You should see something like this:

Google displays the structured data code on the left hand side of the screen and the results of its tests (which check to see that the essential properties are present and that there aren’t any syntax issues with the JSON-LD) are displayed on the right.

From this point on, it’s then a matter of identifying the various types of entities that you’ll want to markup across your website and installing them.

Google has kindly put together guides on how to implement some of the most common structured data markups, for example, here’s the one for the “Logo” markup.

Remember, schema.org has markups for pretty much anything and everything, so it’s highly recommended that you check on here to ensure you’ve marked up the important elements of your web pages.

The Tools

Adding structured data to your website is a long, but rewarding process.

Although there are several tools and plugins available that automatically generate and implement structured data on your website, we’ve found that they are pretty limited (and sometimes erroneous) in how they install the markups.

For WordPress websites, there are a couple of plugins that are mentioned within the SEO community when it comes to structured data.

1. Schema App Structured Data

2. Schema

Both are relatively good at implementing the most basic and important schema.org markups to your website, but again, are nowhere near as comprehensive as a human.

Apart from Google’s Structured Data Markup Helper (which we highly recommend), there aren’t many (good) tools available for non-WordPress websites.

It’s not all doom and doom and gloom though.

As we’ve already seen, Google has published lots of helpful articles on how to markup different types of structured data elements and have launched a number of helpful tools to make it easier for webmasters to install structured data without much hassle.

The Guidelines

As with most SEO best practices, Google has outlined a set of guidelines that webmasters should follow when implementing structured data on their websites.

You can find the full Structured Data Guidelines here, but here are some of the most important ones to take a note of:

Following the above guidelines will help provide Google with as much information as possible about the content on your website.