Try the Schema Generator

Structured Data Is Worth Doing Without the Rich Result

Rich results come and go. Describing your entities accurately with @id and sameAs is the part of structured data that stays useful to every system reading your pages.

November 8, 2026 9 min read
Share: Facebook WhatsApp LinkedIn Email
Structured Data Is Worth Doing Without the Rich Result

Two Things Called Structured Data

There's a version of schema markup that's about rich results — add Recipe markup, get cooking times in the search listing. It's the version most guides cover, and it's genuinely useful for the handful of types that produce visible features.

There's another version that's about making your content machine-parseable, and it matters increasingly as AI systems, aggregators, voice assistants and other consumers read pages without rendering them.

The second version doesn't produce a visible reward, which is why it gets less attention. It's also the one with a longer shelf life, because it doesn't depend on any particular search feature continuing to exist.

What Structured Data Actually Provides

An HTML page carries information in a form built for human reading. A price is styled text next to other styled text. An author name is in a byline the parser has to identify by position or class name. A publication date might be in any of a dozen formats.

A machine reading that page has to infer. Schema markup removes the inference:

{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "How Compound Interest Works",
  "datePublished": "2026-02-14T09:00:00+01:00",
  "dateModified": "2026-08-03T11:30:00+02:00",
  "author": {
    "@type": "Person",
    "name": "Anna Weber",
    "url": "https://example.com/authors/anna-weber"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Example",
    "@id": "https://example.com/#organization"
  }
}

Unambiguous. No parsing heuristics, no guessing which date is which, no wondering whether "Anna Weber" is the author or someone quoted in the article.

The Schema Generator produces JSON-LD blocks:

  1. Select the type.
  2. Fill in the properties.
  3. Copy the output into a <script type="application/ld+json"> tag in the page head.

Why JSON-LD Rather Than Microdata

Three formats exist. JSON-LD is the one to use.

Microdata embeds attributes into your HTML:

<div itemscope itemtype="https://schema.org/Article">
  <h1 itemprop="headline">How Compound Interest Works</h1>
  <span itemprop="author">Anna Weber</span>
</div>

RDFa does something similar with different attribute names.

JSON-LD sits in a separate script block, entirely detached from the markup.

The separation is the advantage. Your structured data doesn't constrain your HTML, doesn't break when a designer restructures the page, and doesn't require touching templates in a dozen places to add one property. It can be generated from the same data that renders the page, in one place.

The tradeoff is that JSON-LD can drift from the visible content, because nothing ties them together mechanically. If the schema says a price is €49 and the page says €59, nothing catches it. Which brings us to the most important constraint.

The Markup Must Match the Page

Structured data describing content that isn't on the page is a policy violation and a straightforward way to lose rich result eligibility.

Specific cases that get sites into trouble:

Review markup for reviews that aren't displayed. Aggregate ratings must correspond to reviews visible on the page.

Self-serving reviews. Marking up reviews of your own business, on your own site, using Review or AggregateRating on the organisation itself.

Prices that don't match. Common with currency or regional variations where the markup is static and the display is dynamic.

FAQ markup for content not shown to users. The questions and answers must be visible on the page.

Product markup on category pages describing a product that isn't the page's subject.

Availability and stock status that's stale because the markup is generated separately from inventory.

The rule is simple: if a user can't see it on the page, don't mark it up. Generating both from the same source is what keeps them aligned.

Entities and @id

The more sophisticated use of schema markup is describing entities rather than pages.

Your organisation isn't a page. It's a thing that has a website, a logo, social profiles, a location and an identity that persists across every page. @id lets you declare it once and reference it everywhere:

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "@id": "https://example.com/#organization",
  "name": "Example Ltd",
  "url": "https://example.com",
  "logo": {
    "@type": "ImageObject",
    "url": "https://example.com/logo.png"
  },
  "sameAs": [
    "https://www.linkedin.com/company/example",
    "https://en.wikipedia.org/wiki/Example"
  ]
}

Every other page can then reference "publisher": {"@id": "https://example.com/#organization"} rather than repeating the full definition.

sameAs is the linking mechanism. It points at other authoritative references to the same entity — a Wikipedia article, a Wikidata entry, official social profiles, a professional registry listing. Each one is a claim that can be checked against an external source, which is what makes the entity identifiable rather than merely asserted.

The same pattern works for authors. A Person entity with a stable @id, referenced from every article they wrote, plus sameAs links to their professional profiles, connects a body of work to an identifiable individual.

This is the durable part of structured data. Rich result features come and go; a clear, verifiable statement of what your organisation is and who writes your content is useful to any system reading the page.

Nesting and Graphs

Real pages describe several related things at once. An article page has an article, an author, a publisher, a webpage and a breadcrumb trail.

Rather than several disconnected script blocks, express them as a graph:

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://example.com/#organization",
      "name": "Example Ltd"
    },
    {
      "@type": "WebSite",
      "@id": "https://example.com/#website",
      "publisher": {"@id": "https://example.com/#organization"}
    },
    {
      "@type": "WebPage",
      "@id": "https://example.com/article/#webpage",
      "isPartOf": {"@id": "https://example.com/#website"}
    },
    {
      "@type": "Article",
      "mainEntityOfPage": {"@id": "https://example.com/article/#webpage"},
      "publisher": {"@id": "https://example.com/#organization"}
    }
  ]
}

The relationships are explicit. A consumer reading this knows the article belongs to a page, which belongs to a site, which is published by an organisation — rather than having four unrelated facts.

This is more useful to non-search consumers than to search engines, which is rather the point of the second version of structured data.

Types Worth Implementing

Regardless of rich result eligibility:

Organization — once, referenced everywhere. Establishes identity.

WebSite — with potentialAction for a search box if you have site search.

BreadcrumbList — cheap, widely supported, clarifies site hierarchy.

Article / NewsArticle / BlogPosting — with author, dates and publisher properly linked.

Person — for authors, with sameAs to professional profiles.

Product — with accurate price, currency and availability.

LocalBusiness — for physical locations, with address, hours and geo coordinates.

HowTo, Recipe, Event, FAQPage — where genuinely applicable and where the content is visible.

A few properties that get skipped and shouldn't:

dateModified — tells consumers how current the content is. Update it when you actually update content, not on every deployment.

inLanguage — unambiguous language declaration.

about and mentions — link to entities the content concerns, ideally with Wikidata or Wikipedia URLs.

Validation Versus Eligibility

Two different checks, and passing one doesn't imply the other.

Syntactic validation confirms the JSON parses, the types exist in the schema.org vocabulary, and the properties are valid for those types.

Rich result eligibility is a separate set of requirements — specific required properties, content policies, and whether the feature exists for your type and region at all.

Markup can be perfectly valid schema.org and produce no rich result, because the feature requires properties you didn't include, or because the feature was retired, or because it isn't available in your market.

Test both. A validator for correctness, a rich results test for eligibility. And don't assume a rich result will appear even when eligible — display is always at the search engine's discretion.

Practical Tips

Generate schema from the same data that renders the page. Hand-maintained markup drifts.

Use @id for entities, not repeated inline definitions.

Add sameAs links to authoritative external references. It's what makes an entity verifiable.

Update dateModified honestly. Bumping it without changing content is a signal nobody benefits from.

Don't mark up what isn't visible.

Validate on a sample of every template, not just one page.

Don't chase retired features. Implement types because they describe your content accurately, not because a feature might return.

FAQ

Which format should I use — JSON-LD, Microdata or RDFa? JSON-LD. It's separate from your markup, easier to generate and maintain, and the widely recommended choice.

Does schema markup improve rankings directly? It isn't a direct ranking factor. It affects eligibility for search features and makes content machine-readable, which matters increasingly for non-search consumers.

What does @id do? Gives an entity a stable identifier so it can be defined once and referenced from anywhere, rather than repeated.

What is sameAs for? Linking an entity to authoritative external references — Wikipedia, Wikidata, official profiles — which makes the entity identifiable rather than merely asserted.

Can I mark up content that isn't visible on the page? No. Structured data must correspond to visible content; doing otherwise risks losing rich result eligibility.

Why does my valid markup produce no rich result? Validation and eligibility are separate. The feature may require additional properties, may not exist for your type, or may not be available in your region.

The Takeaway

Chasing rich results ties your structured data strategy to features that change. Describing your content and entities accurately — with stable identifiers, verifiable external links, and markup that matches what's on the page — produces something useful to every system that reads your site, whether or not any particular search feature survives.

Generate JSON-LD structured data free with the Schema Generator at sadiqbd.com — no sign-up, instant results.

Ask AI about this article
Share: Facebook WhatsApp LinkedIn Email

Schema Generator

Free, instant results — no sign-up required.

Open Schema Generator →
Similar Tools
SEO Checklist Open Graph Generator Link Extractor XML Sitemap Generator Meta Tag Generator Redirect Mapper Canonical Tag Generator Image Alt Checker
Schema Validation vs Rich Results Eligibility: Why Perfectly Valid JSON-LD Can Still Fail Google's Rich Results Test
SEO
Schema Validation vs Rich Results Eligibility: Why Perfectly Valid JSON-LD Can Still Fail Google's Rich Results Test
FAQ Schema Lost Its Rich Results for Most Sites — Here's What That Means for Your Structured Data Strategy
SEO
FAQ Schema Lost Its Rich Results for Most Sites — Here's What That Means for Your Structured Data Strategy
Schema Markup Is About Entities, Not Just Pages — How @id, Organization Hierarchies, and Person Authorship Actually Work
SEO
Schema Markup Is About Entities, Not Just Pages — How @id, Organization Hierarchies, and Person Authorship Actually Work
Schema Markup Is a Claim — Here's How Google Verifies It Through Knowledge Graph Entities and sameAs
SEO
Schema Markup Is a Claim — Here's How Google Verifies It Through Knowledge Graph Entities and sameAs