Skip to content

Glossary Structured Data

What Is Structured Data?

Manuel Riveiro Rodriguez
Manuel Riveiro Rodriguez

CEO & Digital Strategist

8 min reviewed on 2026-08-08

  • SEO Técnico
Definition

Structured data is a standardized vocabulary, usually Schema.org, added to a page's code to tell search engines exactly what a piece of content is (a recipe, a product, a frequently asked question) without changing what the user sees on screen.

A half-open library card drawer, cards standing on edge — beside the title Structured Data
The cards already existed; the order is what makes them readable
On this page 6
  1. What Is Structured Data?
  2. JSON-LD vs. Microdata and RDFa
  3. How It Works
  4. Why It Matters
  5. Best Practices
  6. Common Mistakes
In brief

Which format Google recommends (JSON-LD) versus Microdata and RDFa, what rich results actually are and why they're not a ranking factor, and how to validate markup with Google's own testing tool.

A half-open library card drawer, cards standing on edge — beside the title Structured Data
The cards already existed; the order is what makes them readable

What Is Structured Data?

A web page carries two layers of information. One is the visible content: the text, the images, a product's price. The other is the context a machine needs to read that content the way a person would. Structured data is that second layer: extra code added to the HTML that labels each element with its exact meaning, without touching the page's design or visible text.

The vocabulary most commonly used for this is Schema.org, a joint project launched in 2011 by Google, Microsoft, Yahoo and Yandex. It defines hundreds of types: Product for a product listing, Recipe for a recipe, Article for a blog post, Organization for a company. Each type carries its own properties, a Product might use price, availability or aggregateRating.

Two types matter especially on glossary pages like this one: DefinedTerm, built for marking up the definition of a technical term, and FAQPage, for question-and-answer blocks. This kind of markup falls under technical SEO, alongside page speed and indexability.

JSON-LD vs. Microdata and RDFa

FormatHow it's implementedGoogle's recommendation
JSON-LDA separate code block inside a <script type="application/ld+json"> tagExplicitly recommended format
MicrodataAttributes (itemscope, itemprop) added directly to existing HTML tagsSupported, but not the first choice
RDFaAttributes similar to Microdata, based on a W3C standardSupported, rarely used

Google accepts all three formats, but it has recommended JSON-LD for years wherever a site's setup allows it. Living in a block separate from the visible HTML makes it easier to generate, maintain and debug without risking the page's layout.

-- JSON-LD --
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "What is JSON-LD?",
  "url": "https://zds.es/en/what-is-json-ld/",
  "datePublished": "2026-08-08",
  "author": {
    "@type": "Organization",
    "name": "ZDS",
    "url": "https://zds.es"
  }
}
</script>

-- Microdata --
<div itemscope itemtype="https://schema.org/Article">
  <span itemprop="headline">What is JSON-LD?</span>
  <a itemprop="url" href="https://zds.es/en/what-is-json-ld/">https://zds.es/en/what-is-json-ld/</a>
  <meta itemprop="datePublished" content="2026-08-08">
  <div itemprop="author" itemscope itemtype="https://schema.org/Organization">
    <span itemprop="name">ZDS</span>
    <a itemprop="url" href="https://zds.es">https://zds.es</a>
  </div>
</div>

How It Works

In practice, adding structured data means placing a JSON-LD object in the page's <head> or <body>, using the matching Schema.org type and filling its properties with the page's real data. Google reads it during crawling and indexing, the same way it reads the rest of the HTML.

The search engine doesn't just read the markup in isolation, it checks it against the visible content. If the JSON-LD lists a product at $29 while the page displays $39, Google can ignore that value or, in repeated cases, apply a manual action that strips the page's eligibility for rich results. The markup should always match what the user actually sees, never invented or outdated values.

To check whether the code is well formed and which features it can trigger, Google offers the Rich Results Test, a free tool that analyzes a URL or a code snippet and flags errors and warnings. Search Console adds to this with reports broken down by rich result type, which flag when a template stops generating valid markup after a redesign.

A single page can combine several types: a product listing with Product and, inside the same JSON-LD block, Organization for the brand and BreadcrumbList for the navigation path, without the types conflicting with each other.

Why It Matters

This is the point worth getting exactly right, because it's the most misunderstood one: structured data is not, on its own, a ranking factor. Google states this plainly in its own guidelines: adding markup does not guarantee any rich result element will appear, and a page's standard ranking does not change based on whether it carries markup or not.

What structured data does open up is rich results: star ratings under a product, price ranges, or breadcrumbs shown instead of the full URL. That extra visual layer takes up more space on the results page and tends to bring more clicks, even when the ranking position itself stays the same, much like other technical signals such as Core Web Vitals: neither one moves rankings by itself, but both shape the experience Google measures around them.

There's a second, newer reason that's still hard to back with solid public data: systems that summarize search results with AI, or chatbots that cite web pages, work from the same basic principle as Google Search. They need to understand what a piece of content is about without guessing it from free text. Clean markup makes that automated reading easier, though for now it's more a matter of technical hygiene than a channel with proven results.

Best Practices

  • Default to JSON-LD, and reserve Microdata for templates where you can't touch the <head> section.
  • Validate every new template with the Rich Results Test before publishing it, not after.
  • Only mark up what the user can actually see on the page, no invented reviews, prices or authors just to force a rich result.
  • Pick the most specific Schema.org type available (Recipe instead of a generic CreativeWork) to make use of all its relevant properties.
  • Make markup review a standing item on your technical SEO checklist after every redesign or CMS migration, new templates break JSON-LD more often than expected.
  • Link entities with @id when the same organization or person appears across multiple pages, so Google recognizes them as one entity.

Common Mistakes

  • Copying JSON-LD from a template and leaving placeholder values (prices, dates, names) unedited.
  • Marking up an average rating (aggregateRating) that doesn't appear anywhere visible on the page.
  • Stacking several Schema.org types that don't match the actual content, just to try to trigger more rich results.
  • Letting the markup go stale after a CMS or template change, so it stays in the code with data that no longer matches the page.
  • Using deprecated or misspelled properties the Rich Results Test doesn't recognize, without checking the tool's warnings.
Manuel Riveiro Rodriguez CEO & Digital Strategist

A technical audit covers this and everything else in one pass.

Request an audit

Frequently asked

Does structured data improve rankings?

Not directly. Google uses it to trigger rich results like stars, prices, or a breadcrumb trail, which make a listing more visible and can drive more clicks. The position within standard rankings doesn't change because of it, Google confirms this in its own structured data guidelines. FAQPage markup is still valid, but as of May 2026 it no longer triggers any visible element in the search result.

Which format should I use, JSON-LD, Microdata or RDFa?

JSON-LD, whenever your site's setup allows it. It's the format Google explicitly recommends because it lives in its own code block, making it easier to build and maintain without touching the visible HTML or risking the template's layout, especially across large sites with many templates.

How do I check if my markup is correct?

With Google's free Rich Results Test: paste in a URL or code snippet and it shows which types it detects, which properties are missing and any errors. Search Console adds reports per rich result type that flag when a template stops producing valid markup after a change.

Can I lose a rich result for marking up data that isn't visible?

Yes. Google's guidelines prohibit marking up content that isn't visible to the user, like a fake review or a price shown nowhere on the page. In repeated cases, Google can apply a manual action that removes rich result eligibility for those pages, though the rest of the site's ranking stays unaffected.

Does structured data help with ChatGPT or Google's AI-generated answers?

It helps content get identified unambiguously, which is useful for any automated system processing it. There's no solid public data yet on the size of that effect, so it's worth treating as sound technical practice rather than a guarantee of being featured.

Sources

  1. 10.12.2025 Google Search Central: Understand how structured data works: confirms Google's explicit JSON-LD recommendation and explains rich results and the Rich Results Test. Updated December 10, 2025.
  2. 10.07.2026 Google Search Central: Structured data general guidelines: clarifies that markup doesn't guarantee a rich result and that standard ranking stays unaffected. Updated July 10, 2026.
  3. Schema.org: the official vocabulary from Google, Microsoft, Yahoo and Yandex, with over 450 billion marked-up objects across more than 45 million domains.