Tech for Retail 2025 Workshop: From SEO to GEO – Gaining Visibility in the Era of Generative Engines

Back to blog

Schema for SEO: how to choose, validate and optimise your markup

SEO

Discover Incremys

The 360° Next Gen SEO Platform

Request a demo
Last updated on

1/11/2026

Chapter 01

Example H2
Example H3
Example H4
Example H5
Example H6

An SEO schema is schema.org markup added to a page to describe its content to machines. The guide to structured data: definition, formats and which types to mark up sets out the method and prioritisation. This page is the implementation library: which types and properties to choose, ready-to-adapt JSON-LD examples for Article, Product, BreadcrumbList, LocalBusiness and Organization, an entity graph for a B2B site, then the method to deploy this markup by template, validate it and maintain it.

 

Understanding Schema for SEO: What Markup Delivers, and Why JSON-LD

 

Schema.org markup makes explicit information that the search engine would otherwise have to infer from HTML signals: which entity the page describes, with which attributes and which relationships. It helps Google interpret and categorise a page, and can make it eligible for rich results: price, availability, breadcrumbs, logo. Other systems read it too: search engines, link previews, assistants and the crawlers of generative engines.

 

The format used here is JSON-LD, which Google recommends: a block separate from the visible HTML, which you generate from your templates without touching the rendering.

 

What Markup Does Not Replace

 

Accurate markup does not make up for weak foundations. It does not replace:

 

  • content quality: usefulness, accuracy, structure of headings and paragraphs;
  • overall technical hygiene: indexability, performance, canonical tags;
  • the page's relevance to the search intent you are targeting.

 

Structured data are not a direct ranking factor: they act on how the page is understood and, when it is eligible, on the form of the snippet, with no guarantee of display.

 

Structured Data Formats: JSON-LD, Microdata and RDFa

 

Google reads three formats: JSON-LD (a <script type="application/ld+json"> block, in the <head> or the <body>), Microdata (itemscope, itemtype, itemprop attributes on visible elements) and RDFa (vocab, typeof, property attributes). The choice mainly affects maintenance: JSON-LD survives component redesigns, while the other two are tied to them.

 

If your theme already outputs attributes in the HTML, the guide to Microdata with code examples explains when to keep them and how to migrate.

 

Which Types to Mark Up, with Which Properties: Where Google Display Stands

 

Each type has its required properties (without them, no eligibility), its recommended properties and its display status. The table below summarises the situation at the time of writing, based on Google Search Central documentation:

 

TypeRequired propertiesRecommended propertiesGoogle display (at the time of writing)
Article / BlogPostingNone imposed by Googleheadline, image, datePublished, dateModified, authorActive: title, image, date, author
Product + Offername and at least offers, review or aggregateRatingprice, priceCurrency, availability, image, brand, gtinActive: price, availability, compliant reviews
BreadcrumbListitemListElement (position, name, item)One level per real step in the breadcrumb trailShown on desktop; breadcrumbs no longer shown on mobile since early 2025
OrganizationNone imposed by Googlename, url, logo, sameAs, contactPointActive: logo and organisation details
LocalBusinessname, addresstelephone, url, geo, openingHoursSpecificationActive: address, opening hours, contact details
SoftwareApplicationname, offers, and aggregateRating or reviewapplicationCategory, operatingSystemActive: reviews and price, subject to eligibility criteria
ServiceNone (schema.org type with no rich result)name, provider, serviceType, areaServedUnderstanding, no display
Eventname, startDate, locationendDate, eventStatus, organizer, offersActive, subject to eligibility criteria
VideoObjectname, thumbnailUrl, uploadDatedescription, duration, contentUrlActive, subject to eligibility criteria
FAQPagemainEntity (Question, acceptedAnswer)Questions and answers visible on the pageFAQ rich results restricted since August 2023 to authoritative government and health websites; no display for a B2B site
HowToname, steptool, supply, totalTimeHowTo rich results removed in September 2023; the type remains valid in schema.org

 

Two further removals complete this table: the sitelinks search box (WebSite + SearchAction) was removed at the end of 2024, and Google has not used rel=prev/next since 2019. Service, FAQPage and HowTo remain readable by the other systems that use schema.org.

 

High-Impact Schema.org Types: Code Examples for Article, Product, BreadcrumbList, LocalBusiness and Organization

 

Each example below should be adapted to your own fields, with one common rule: only declare what the page displays, with the same values.

 

Article: Mark Up Editorial Content Without Over-Declaring

 

For editorial content, the aim is to make the title, date, author, image and publisher explicit. Here is Article markup with a Person author and an Organization publisher:

 

  • <script type="application/ld+json">
  • {
  •   "@context": "https://schema.org",
  •   "@type": "Article",
  •   "headline": "A practical guide to implementing schema.org markup in JSON-LD",
  •   "image": ["https://www.example.com/images/schema-json-ld.jpg"],
  •   "datePublished": "2026-02-21",
  •   "author": {
  •     "@type": "Person",
  •     "name": "First name Surname",
  •     "url": "https://www.example.com/authors/first-name-surname"
  •   },
  •   "publisher": {
  •     "@type": "Organization",
  •     "name": "Organisation name",
  •     "url": "https://www.example.com",
  •     "logo": { "@type": "ImageObject", "url": "https://www.example.com/images/logo.png" }
  •   }
  • }
  • </script>

 

If the author is not shown on the page, do not declare it; the same applies to dates and images. Only add dateModified if the update date is visible and managed by the CMS. If your Organization is already declared, reference its @id in publisher.

 

Product: Structure a Product Page for Rich Results

 

The Product type, completed by an Offer, exposes price, currency and availability, which Google can show in the snippet:

 

  • <script type="application/ld+json">
  • {
  •   "@context": "https://schema.org",
  •   "@type": "Product",
  •   "name": "Ergonomic office chair",
  •   "description": "Adjustable chair with lumbar support.",
  •   "image": ["https://www.example.com/images/ergonomic-chair.jpg"],
  •   "brand": {
  •     "@type": "Brand",
  •     "name": "Example brand"
  •   },
  •   "offers": {
  •     "@type": "Offer",
  •     "url": "https://www.example.com/products/ergonomic-chair",
  •     "priceCurrency": "EUR",
  •     "price": "199.90",
  •     "availability": "https://schema.org/InStock"
  •   }
  • }
  • </script>

 

Three points to watch. The marked-up price must change at the same moment as the visible price, which means both come from the same field. Availability uses a normalised schema.org value (InStock, OutOfStock, PreOrder), never free text. Ratings (aggregateRating) should only be added if they are genuinely displayed and substantiated.

 

BreadcrumbList: Make Navigation Hierarchy Explicit

 

BreadcrumbList describes a breadcrumb trail that already exists on the page. Google can show that hierarchy in place of the URL on desktop; on mobile, it has not shown it since early 2025, but the hierarchy remains useful for understanding the site. Here is a three-level trail, one element per line:

 

  • <script type="application/ld+json">
  • {
  •   "@context": "https://schema.org",
  •   "@type": "BreadcrumbList",
  •   "itemListElement": [
  •     { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://www.example.com/" },
  •     { "@type": "ListItem", "position": 2, "name": "Blog", "item": "https://www.example.com/blog/" },
  •     { "@type": "ListItem", "position": 3, "name": "JSON-LD markup", "item": "https://www.example.com/blog/json-ld-markup/" }
  •   ]
  • }
  • </script>

 

The marked-up hierarchy must match the visible breadcrumb trail and the real site architecture: same labels, same URLs, same positions.

 

LocalBusiness: Clarify Local Presence (Address, Opening Hours, Geolocation)

 

LocalBusiness describes a location: name, address, phone number, opening hours, coordinates. Here is an example with opening days expressed as schema.org values:

 

  • <script type="application/ld+json">
  • {
  •   "@context": "https://schema.org",
  •   "@type": "LocalBusiness",
  •   "name": "Location name",
  •   "url": "https://www.example.com/locations/paris-1",
  •   "telephone": "+33-1-00-00-00-00",
  •   "address": {
  •     "@type": "PostalAddress",
  •     "streetAddress": "10 rue Exemple",
  •     "addressLocality": "Paris",
  •     "postalCode": "75001",
  •     "addressCountry": "FR"
  •   },
  •   "geo": { "@type": "GeoCoordinates", "latitude": 48.864716, "longitude": 2.349014 },
  •   "openingHoursSpecification": [{ "@type": "OpeningHoursSpecification",
  •     "dayOfWeek": ["https://schema.org/Monday", "https://schema.org/Tuesday", "https://schema.org/Wednesday", "https://schema.org/Thursday", "https://schema.org/Friday"],
  •     "opens": "09:00",
  •     "closes": "18:00" }]
  • }
  • </script>

 

Days are written with schema.org values ("https://schema.org/Monday" or "Monday"), not in lower case or translated. Keep the marked-up name, address and phone number strictly consistent with those shown on the page and those published elsewhere.

 

Organization: The Node That Identifies the Brand

 

The Organization type makes explicit the entity that publishes the site: official name, logo, profiles and contact points. It serves as the foundation for other entities (publisher, provider, brand). Here is an Organization with a stable @id:

 

  • <script type="application/ld+json">
  • {
  •   "@context": "https://schema.org",
  •   "@type": "Organization",
  •   "@id": "https://www.example.com/#organization",
  •   "name": "Organisation name",
  •   "url": "https://www.example.com/",
  •   "logo": {
  •     "@type": "ImageObject",
  •     "@id": "https://www.example.com/#logo",
  •     "url": "https://www.example.com/images/logo.png"
  •   },
  •   "sameAs": ["https://www.linkedin.com/company/example", "https://www.youtube.com/@example"],
  •   "contactPoint": [{
  •     "@type": "ContactPoint",
  •     "contactType": "support",
  •     "email": "support@example.com",
  •     "availableLanguage": ["en"]
  •   }]
  • }
  • </script>

 

The @id is an identifier, not a page: choose it once for the whole site and reuse it everywhere the organisation is referenced. Reviews of your own organisation are not eligible for rich results: do not mark them up here.

 

FAQPage and HowTo: What Has Changed Since 2023

 

FAQPage no longer brings a rich result to a B2B site: since August 2023, Google has restricted it to authoritative government and health websites. The type keeps its value as an explicit question-and-answer structure for other systems and AI crawlers, with no demonstrated measurable effect.

 

The code, compliance rules and decision grid are in the guide to marking up a FAQ with FAQPage since the 2023 restriction.

 

HowTo remains a valid schema.org type, but its rich result was removed in September 2023; it remains readable by the other systems that use the vocabulary.

 

B2B Sites: Connecting Entities

 

A B2B site mainly describes an organisation, its services, its software and its authors. The value of the markup then lies in the consistency of the graph: each entity declared once, with a stable identifier, and connected to the others by reference.

 

An @graph: Organization, WebSite and Service on the Same Page

 

The @graph property groups several entities in a single block and connects them through their @id values. Here is the foundation of a service page: the organisation, the website it publishes and the service it provides.

 

  • <script type="application/ld+json">
  • {
  •   "@context": "https://schema.org",
  •   "@graph": [
  •     { "@type": "Organization",
  •       "@id": "https://www.example.com/#organization",
  •       "name": "Example Consulting",
  •       "url": "https://www.example.com/",
  •       "logo": "https://www.example.com/images/logo.png",
  •       "sameAs": ["https://www.linkedin.com/company/example"] },
  •     { "@type": "WebSite",
  •       "@id": "https://www.example.com/#website",
  •       "url": "https://www.example.com/",
  •       "publisher": { "@id": "https://www.example.com/#organization" } },
  •     { "@type": "Service",
  •       "@id": "https://www.example.com/services/audit/#service",
  •       "name": "Structured data audit",
  •       "serviceType": "SEO consulting",
  •       "areaServed": "FR",
  •       "provider": { "@id": "https://www.example.com/#organization" } }
  •   ]
  • }
  • </script>

 

For a software publisher, replace the Service node with a SoftwareApplication (applicationCategory, offers, publisher pointing to the organisation). Do not add a SearchAction to the WebSite: the sitelinks search box was removed at the end of 2024.

 

A Pivot Organization Node, Referenced Everywhere

 

The principle rests on three rules: a single Organization for the whole site, an @id that never changes, and references to that @id rather than copies of the object. The table below suggests an identifier convention for a B2B site:

 

NodeSuggested @idDeclared onReferenced by
Organization/#organizationEvery page (shared template)publisher, provider, brand, worksFor
WebSite/#websiteEvery pageisPartOf of pages
Service/services/[slug]/#serviceThe service pagemakesOffer of the organisation, related articles
SoftwareApplication/software/#softwareThe software product pageFeature pages, pricing
Person (author)/authors/[slug]/#personThe author pageauthor of articles

 

The sameAs property connects the organisation to its official profiles (professional network, video channel, knowledge base): it confirms that it is the same entity from one source to another. Only list profiles you control.

 

What This Graph Brings to Generative Engines

 

The crawlers of generative engines (GPTBot and OAI-SearchBot, ClaudeBot, PerplexityBot, Googlebot for AI Overviews and AI Mode) read the HTML, and therefore the markup. A consistent graph helps them understand who publishes the page and what it describes, and supports an accurate rendering of the name, facts and attribution. No direct effect of markup on being cited has been demonstrated at the time of writing. To go further, see what generative engines take from markup.

 

A JSON-LD Implementation Method: from Page to Code You Can Validate

 

Markup is designed by template, not by page. The method has five steps, to be repeated for each template:

 

  • Select the templates to mark up: those that combine business value, URL volume and verifiable information.
  • Map entities and properties: the main entity, its required properties, then the recommended ones; also decide what is excluded (reviews not displayed, data that is not updated automatically).
  • Produce robust JSON-LD: @context set to "https://schema.org", an @type that matches the actual template, stable @id values, normalised values when the vocabulary provides them.
  • Integrate the code into the template: the template generates the block from CMS fields; a tag manager can serve for a prototype, at the cost of a risk of drift.
  • Test, fix and monitor: validation before release, then monitoring of the reports.

 

Mapping CMS Fields to Schema.org Properties

 

The core of the method is a mapping table between CMS fields and properties, which ensures that the page and the markup read the same source. Example for common fields:

 

CMS fieldschema.org propertyType concernedCheck
Page titleheadline / nameArticle / Product, ServiceIdentical to the displayed title
Authorauthor (Person, with url or @id)ArticleVisible author and an existing author page
Publication / update datedatePublished / dateModifiedArticleISO 8601 format, identical to the displayed date
Main imageimageArticle, ProductAbsolute URL, image accessible to crawlers
Priceoffers.price + priceCurrencyProduct, SoftwareApplicationDecimal point, currency as an ISO code
Stockoffers.availabilityProductschema.org value, updated at the same time as the page
Addressaddress (PostalAddress)LocalBusiness, OrganizationIdentical to the page and other sources

 

Version this table like code: every change to a field goes through it, then through a new test.

 

Deploying Without Duplicates: A Single Source of Truth

 

Inconsistencies mostly come from two generators describing the same page. Before adding a block, take stock of the final HTML:

 

  • a CMS plugin often generates baseline markup (Organization, WebSite, Article): decide whether it remains the single source or whether the template replaces it, never both;
  • Microdata inherited from an old theme sometimes coexists with recent JSON-LD: choose a target format and progressively remove the other;
  • markup injected by a tag manager escapes template governance: limit it to prototypes.

 

Keep @id values identical from one template to another and check the final rendering after each release: caching, JavaScript rendering or a CMS update can change what crawlers receive.

 

Validating and Monitoring Markup

 

Two checks complement each other before release. The Rich Results Test checks eligibility for Google rich results, on a URL or a code snippet; the Schema.org validator checks vocabulary compliance for all types, without saying anything about display. The guide to testing your structured data with the Rich Results Test covers each tool and how to read the results.

 

After deployment, monitoring happens in Search Console. Three habits cover the routine:

 

  • read the Enhancements reports by type, which classify pages as Valid, Valid with warnings and Invalid;
  • handle errors first (page not eligible), then warnings (missing recommended property) on high-stakes pages;
  • retest after every template change and every migration, then start the fix validation.

 

For detailed use of the reports and URL Inspection, see the guide to Google Search Console for monitoring your pages. Then measure the effect on impressions and CTR for marked-up pages, without attributing seasonal variations to it.

 

Common Errors: What Breaks Eligibility or Consistency

 

The most costly errors are gaps between the page and the markup. The table below pairs each one with its effect and its fix:

 

ErrorEffectFix
Invalid JSON (comma, quote, brace)Entire block ignoredGenerate the JSON from the template, validate before release
Missing required propertyError in the reports, page not eligibleComplete the mapping for the type
Price, stock, author or date different from the pageLoss of the rich result, wrong facts reused elsewhereFeed the page and the markup from the same CMS field
Information marked up but not visible (reviews, FAQ)Risk of a manual action for spammy structured dataOnly mark up what is visible and accurate
Several competing main entities (an article also declared as Product)Ambiguous page typeOne main type, supporting types nested or connected by @id
Duplicate CMS plugin + template, or Microdata + JSON-LDTwo contradictory entities on the same pageA single source of truth per page
Unstable or missing @id valuesEntities not connected from one page to anotherFixed @id values and a single Organization node
Free-text values ("monday", "in stock")Value not recognised by the vocabularyUse schema.org enumerations

 

Fix in this order: blocking errors, automatic updates of variable fields, recommended properties on high-stakes pages, then extension to the next template.

 

Depending on Your Situation

 

Depending on your starting point, these resources extend this library:

 

 

To have markup generated by template at every publication, from the same fields as the page, the Incremys CMS Integration module, a GEO & SEO platform, connects your content to your CMS and publishes its JSON-LD with it.

 

FAQ on Schema for SEO and JSON-LD Markup

 

What Is an SEO Schema?

 

It is markup based on the schema.org vocabulary, added to a page to describe its content to machines: organisation, product, article, author, location. It helps search engines understand the page and can make it eligible for rich results. The format Google recommends is JSON-LD, a block separate from the visible HTML.

 

Which Types Should a B2B Site Mark Up First?

 

Start with Organization across the whole site, with a stable @id, then WebSite. Add Service on offer pages, SoftwareApplication for software, Article and Person on the blog, and BreadcrumbList on navigation. LocalBusiness only applies to offices that receive the public. Connect all these nodes to the organisation by reference.

 

Can You Combine Multiple Schema Types on the Same Page?

 

Yes, as long as the combination reflects the page: one main type plus supporting types (BreadcrumbList, Organization, Person). The cleanest approach is to group them in a single @graph block, connected by their @id values. Avoid two competing main entities, such as an article also declared as Product.

 

What Is @id For?

 

It is a unique entity identifier, written as a URL, for example the domain followed by #organization. It lets you declare an entity once and cite it elsewhere by simple reference. Search engines can then link the publisher of an article, the provider of a service and the site's organisation to the same entity.

 

Should You Mark Up a Page with HowTo?

 

Not for display: Google removed the HowTo rich result in September 2023. The type remains valid in schema.org and explicitly structures steps for the other systems that read it. If the page genuinely describes a visible procedure, the markup is still possible; otherwise, Article is enough.

 

Is a Plugin Enough?

 

To get started, a CMS plugin often covers Organization, WebSite and Article. It reaches its limits on business-specific types, shared @id values and variable fields such as price or opening hours. Check the final HTML, then choose a single source of truth: the plugin or the template, never both on the same entities.

 

What Happens If a Required Property Is Missing?

 

The page is no longer eligible for the corresponding rich result, and Search Console classifies it as invalid in the report for that type. The rest of the markup is still read. A missing recommended property, by contrast, only produces a warning: the page remains eligible, with a less complete snippet.

Discover other items

See all

Next-Gen GEO/SEO starts here

Complete the form so we can contact you.

The new generation of SEO
is on!

Thank you for your request, we will get back to you as soon as possible.

Oops! Something went wrong while submitting the form.