JSON-LD: what it is, which schema types still matter, and how to implement it

What is JSON-LD?

JSON-LD (JavaScript Object Notation for Linked Data) is a way to describe a page’s content in machine-readable form, inside a single <script type="application/ld+json"> block in the page’s HTML. The block is invisible to visitors. Machines read it instead of guessing what the page means from layout and styling.

Three properties explain why it won. It is separate: the markup lives in one block, not woven through your HTML like the older microdata and RDFa formats, so it can be templated and maintained without touching the visible page. It is explicit: "priceCurrency": "EUR" leaves nothing to interpretation. And it is the recommended format: Google has named JSON-LD its preferred structured-data syntax for years, and virtually all modern tooling assumes it.

What is schema.org, and how does it relate to JSON-LD?

Schema.org is the vocabulary; JSON-LD is the grammar. Schema.org is a shared dictionary of types (Product, Organization, Article, FAQPage…) and properties (price, logo, author…) that machines agree on, founded in 2011 by Google, Microsoft, Yahoo and Yandex precisely so the web wouldn’t need a separate dialect per search engine. JSON-LD is the format you write that vocabulary in.

The dictionary is huge, around 800 types, and that scale misleads. Only a small subset triggers any visible feature in search, and nothing obliges you to use the rest. The craft lies in picking the handful of types that machines demonstrably consume, and implementing those correctly.

Why does structured data still matter in 2026?

Because three different audiences of machines read it, and each pays out differently.

Google’s rich results and merchant listings. Correct markup makes pages eligible for enhanced search appearances: product snippets with price, stock status and star ratings, article headers, breadcrumb trails. And, for stores, Google’s free merchant listings, where product data including shipping and return information is drawn directly from markup. Eligibility, not guarantee: Google decides per query what to show. But results with rich data visibly stand out, and that is a click-through advantage no one has retired.

The wider AI ecosystem. Microsoft has said publicly (via principal product manager Fabrice Canel in March 2025) that schema markup helps its LLMs understand web content, feeding Bing and Copilot. Google, meanwhile, stated in May 2026 that structured data is not required for AI Overviews or AI Mode. And an Ahrefs study of 1,885 pages that added JSON-LD found essentially no change in how often AI systems cited them. The honest synthesis: structured data doesn’t make AI systems quote you. Content does. But it removes ambiguity about what your pages say, for every machine that reads raw HTML. Disambiguation is cheap insurance, not a growth lever. JSON-LD isn’t the only machine-readable layer worth having either; our guide to llms.txt covers the text-file counterpart aimed squarely at AI crawlers.

The knowledge graph: machines learning who you are. An Organization block with sameAs links pointing to your Wikidata entry, Wikipedia page and official profiles helps machines connect your domain to one unambiguous entity. That identity layer matters more each year: when an AI assistant decides whether “Example Store” in a forum thread is you or a namesake, entity data is what it falls back on. We go deeper on this in our guide to the knowledge graph and Wikidata.

None of this replaces the bigger picture. Structured data is technical foundation, not a growth lever. For how it fits with search, answer engines and AI assistants overall, see our guide to SEO, AEO, GEO and AIO.

Which schema types does Google still reward, and which are retired?

The active list is shorter than most guides admit, because Google has spent 2023–2026 pruning. What remains, and what it earns:

And the retirement log, markup that no longer triggers anything visible in Google:

Two clarifications keep this table honest. Retired markup is not penalized: Google simply ignores it, and unsupported types produce no errors. And retirement of the visual reward is not retirement of the markup’s meaning: FAQPage markup still labels your questions and answers for every other machine reading your HTML, which is why we still recommend it as the final step after writing genuine Q&A content, a case we make at length in our FAQ schema article.

Which types should an online store prioritize?

In order of return on effort:

1. `Product` with a complete `Offer`. The commercial core: name, image, description, brand, GTIN, price, currency, availability, plus shipping costs and return policy (OfferShippingDetails, MerchantReturnPolicy), which Google’s merchant listings display directly. Stores with product data in markup compete in surfaces that unmarked stores simply don’t appear in.
2. `Organization` with `sameAs`. One block, site-wide, linking your name, logo, and official profiles, including your Wikidata entity if one exists. This is the cheapest work you can do for machine-readable identity.
3. `BreadcrumbList`. Trivial to implement, shown in results, and gives machines your site’s hierarchy for free.
4. `FAQPage` on product, delivery and service pages. No Google stars anymore, but it labels your most quotable content for the wider ecosystem, and writing it enforces answer-shaped content.
5. `Article` on your guides and posts. Modest gains, near-zero cost when templated once.
6. `LocalBusiness`, if you have physical stores. Hours, address and geo-coordinates for local search.

How do you implement JSON-LD in practice?

1. Audit what you already have. Most platforms (Shopify, WooCommerce, Wix and the rest) emit some JSON-LD out of the box, and SEO plugins add more. Run key pages through validator.schema.org before adding anything. The most common enterprise mistake is three plugins emitting three conflicting Product blocks.
2. Work per template, not per page. Decide which types belong on each page template (product template, category, article, contact), and generate the markup from the same data that renders the visible page. Hand-written JSON-LD goes stale; templated JSON-LD can’t.
3. Mirror the visible content exactly. Markup describes what’s on the page: the same price, the same claims. Marking up content that visitors can’t see violates Google’s guidelines and is the classic path to a manual action.
4. Connect your entities. Give the site-wide Organization an @id and reference it from products (brand, publisher) so machines see one connected graph instead of disconnected fragments.
5. Validate twice. validator.schema.org checks the vocabulary; Google’s Rich Results Test checks eligibility for Google’s own features. Both are free and take seconds.
6. Monitor in Search Console. The enhancement reports show which pages have valid, invalid, or missing markup, and alert you when a template change silently breaks it.
7. Keep it alive. Price and availability change constantly; that’s why step 2 matters. A JSON-LD block asserting an old price is worse than none: it is wrong data served with machine confidence.

What does correct JSON-LD look like?

Two compact, realistic examples. First, the site-wide identity block:

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "@id": "https://www.example-store.com/#organization",
  "name": "Example Store",
  "url": "https://www.example-store.com/",
  "logo": "https://www.example-store.com/logo.png",
  "sameAs": [
    "https://www.wikidata.org/wiki/Q00000000",
    "https://www.instagram.com/examplestore",
    "https://www.linkedin.com/company/example-store"
  ]
}

Second, a product page with the offer details merchant listings consume:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Ridgeline Trail Shoe",
  "image": "https://www.example-store.com/img/ridgeline-trail.jpg",
  "description": "Lightweight trail-running shoe with a 6 mm drop and a grippy outsole, built for wet terrain.",
  "brand": { "@type": "Brand", "name": "Ridgeline" },
  "gtin13": "5701234567890",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.6",
    "reviewCount": "214"
  },
  "offers": {
    "@type": "Offer",
    "price": "129.00",
    "priceCurrency": "EUR",
    "availability": "https://schema.org/InStock",
    "shippingDetails": {
      "@type": "OfferShippingDetails",
      "shippingRate": { "@type": "MonetaryAmount", "value": "4.90", "currency": "EUR" },
      "shippingDestination": { "@type": "DefinedRegion", "addressCountry": "DE" }
    },
    "hasMerchantReturnPolicy": {
      "@type": "MerchantReturnPolicy",
      "applicableCountry": "DE",
      "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
      "merchantReturnDays": 30,
      "returnFees": "https://schema.org/FreeReturn"
    }
  }
}

Note what makes these correct rather than decorative: every value mirrors something visible on the page, the rating exists only because reviews are shown there, and the identifiers (gtin13, @id) are the hooks other systems use to match this product and this company across the web.

What are the most common JSON-LD mistakes?

• Marking up content that isn’t on the page: aspirational ratings, invisible FAQs. Guideline violation, spam risk, zero benefit.
• Conflicting duplicates from platform + plugin + theme all emitting markup. Machines meet three different prices and trust none.
• Stale data: markup asserting last season’s price because it was hand-written once and forgotten.
• Syntax errors: one trailing comma silently invalidates the whole block. This is why validation belongs in the workflow, not in the launch week.
• Orphan effort: implementing exotic types nothing consumes, while Product lacks GTIN and shipping data.
• Expecting a ranking boost. Structured data is not a ranking factor. It changes how you appear and what machines know, not where you rank.

Final thoughts

Structured data in 2026 asks for a cooler head than the hype cycle around it. Google retired the FAQ stars, the how-to panels and half a dozen other rewards. Yet product markup drives real merchant-listing visibility, entity markup feeds the knowledge graph, and every AI crawler reading your raw HTML meets your JSON-LD before it meets your prose. In our August 2026 audit of 99 online stores (in Norwegian), 56% of readable sites had no JSON-LD at all, and 12 of 99 lacked structured data, a Wikidata entity and every agent signal at once: invisible to machines on every count.

So the opportunity is the same one running through everything we publish: the floor is empty. Write pages worth describing, then describe them precisely: product data complete, identity connected, markup mirroring what’s visible. It won’t make machines love you. It makes sure that when they read you, they get you right, and right now, that alone puts you ahead of half the market.