Schema markup for AI: which structured data helps and how to get it right

Schema markup for AI is structured data in JSON-LD that records in machine-readable form who you are, what a page is and which facts it contains. It makes entities such as your company, your authors and your products unambiguous. Google demonstrably uses structured data for search results. Exactly how the LLMs behind ChatGPT, Gemini and Perplexity use it is not public.

This article is part of the complete guide to GEO. You'll read what structured data is, what is and isn't known about how AI uses it, which types matter and how to build a complete JSON-LD block. After that come the pitfalls and how to validate your markup.

One thing up front: schema markup is no substitute for good writing. It helps a machine connect the facts that are already on your page. The text itself still needs to be content that AI cites.

#What are structured data, schema markup and JSON-LD?

Structured data is a standardised description of a page and the things on it, in a format a machine can read without interpretation. In its introduction to structured data, Google describes it as a standardised format for providing information about a page and classifying its content.

Three terms are often mixed up:

In the same documentation, Google recommends choosing the format that is easiest for you to maintain, and says that in most cases this is JSON-LD. The advantage is practical: you don't have to rebuild your HTML, and you can link several entities together in one block.

#What is known about how AI uses schema markup?

What is certain is that Google uses structured data for search results and rich results, and that it also uses that data to gather information about the world, such as people, books and companies. In its introduction, Google explicitly says it can make broad use of the sameAs property and other schema.org data.

Google is also clear about AI features. Its documentation on AI features and your website says you don't need special schema.org markup or separate AI files to appear in AI Overviews or AI Mode. Google does cite it as good practice for your structured data to match the visible text on the page.

What isn't known is how OpenAI, Perplexity and other providers process structured data. They don't publish any documentation on it. A reasonable, cautious conclusion is this:

• JSON-LD sits as text in the HTML. A crawler that fetches your page therefore gets it too.
• With retrieval-augmented generation, a system looks up sources and bases its answer on them. Unambiguous facts (name, address, author, date, price) make it easier to connect a source correctly and cite it.
• For Google, it's documented that structured data counts for search results. An AI system that relies on such a search index may benefit indirectly, but this hasn't been confirmed.

Anyone who claims schema markup is guaranteed to get you into ChatGPT is claiming more than anyone can back up. Anyone who says it's pointless is ignoring that the largest search engine actively uses it. You can read more about the selection process in how AI search engines choose sources.

#Which schema types count and when do you use them?

The types that contribute most are the ones that describe your company, your authors and your most important pages unambiguously. For each type, only use the properties that are actually on the page.

#Organization and LocalBusiness with sameAs

Organization markup says who is behind the site, and sameAs links that organisation to the same entity elsewhere on the web. In its Organization documentation, Google advises placing this markup on the homepage or a single page about your organisation, and using the most specific subtype. For a shop, practice or restaurant, that's a subtype of LocalBusiness.

According to schema.org, sameAs is the URL of a reference page that unambiguously indicates the item's identity. Think of your LinkedIn company page, your Wikidata item, your company registration listing or a Wikipedia article if you have one. This helps a system see that "The Spoke" on your site and "The Spoke" on LinkedIn are the same company. It ties in with how a knowledge graph connects entities.

#WebSite and BreadcrumbList

WebSite gives your site as a whole a name and links it to the publisher. BreadcrumbList shows where a page sits in the hierarchy. According to its breadcrumb documentation, Google uses breadcrumb markup to categorise the content of a page in search results, and it asks for at least two items.

#Article with author and dates

Article markup records who wrote something and when, two signals that relate directly to E-E-A-T. Google's Article documentation has no required properties, but recommends author, datePublished, dateModified, headline and image. Google asks you to list each author separately, as a Person with a url or sameAs, and to put only the name in author.name.

#Product and Offer

Product markup makes a product's price, availability and identification unambiguous. For product pages where you can buy directly, Google's merchant listing documentation requires at least name, image and an Offer with price (greater than zero) and priceCurrency as an ISO 4217 code, such as EUR. Recommended properties include brand, gtin or sku, availability and itemCondition.

#FAQPage: note its current status

FAQPage is still a valid schema.org type, but Google no longer shows rich results for it. In September 2023, Google had already limited FAQ rich results to well-known, authoritative government and health websites. According to the Google Search Central changelog, the feature has not appeared in Google Search at all since 7 May 2026, and the documentation was removed on 15 June 2026.

So only use FAQPage if you have real questions and answers visible on the page. It then explicitly links question and answer, but don't expect an expandable block in Google from it.

#Person

Person markup gives authors and key people their own identity, separate from the company. Use it on an author or team page and refer to it from author in your articles. With sameAs pointing to, for example, a LinkedIn profile, you make clear which person it is.

#Complete JSON-LD example with @graph

With @graph, you put several entities in one JSON-LD block and refer to them with a fixed @id. Below is the markup for a knowledge base article from the fictional bike repair shop "The Spoke Cycle Workshop" in Bristol. All names, addresses and URLs are made up.

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "BicycleStore",
      "@id": "https://www.thespoke-example.com/#organization",
      "name": "The Spoke Cycle Workshop",
      "url": "https://www.thespoke-example.com/",
      "logo": "https://www.thespoke-example.com/images/logo.png",
      "image": "https://www.thespoke-example.com/images/shop.jpg",
      "telephone": "+44 117 000 0000",
      "email": "info@thespoke-example.com",
      "address": {
        "@type": "PostalAddress",
        "streetAddress": "12 Example Street",
        "postalCode": "BS1 0AA",
        "addressLocality": "Bristol",
        "addressCountry": "GB"
      },
      "openingHoursSpecification": [
        {
          "@type": "OpeningHoursSpecification",
          "dayOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
          "opens": "09:00",
          "closes": "18:00"
        }
      ],
      "sameAs": [
        "https://www.linkedin.com/company/thespoke-example",
        "https://www.instagram.com/thespoke-example"
      ]
    },
    {
      "@type": "WebSite",
      "@id": "https://www.thespoke-example.com/#website",
      "name": "The Spoke Cycle Workshop",
      "url": "https://www.thespoke-example.com/",
      "inLanguage": "en-GB",
      "publisher": { "@id": "https://www.thespoke-example.com/#organization" }
    },
    {
      "@type": "Person",
      "@id": "https://www.thespoke-example.com/about-us/sam-taylor#person",
      "name": "Sam Taylor",
      "jobTitle": "Head Mechanic",
      "url": "https://www.thespoke-example.com/about-us/sam-taylor",
      "worksFor": { "@id": "https://www.thespoke-example.com/#organization" },
      "sameAs": ["https://www.linkedin.com/in/sam-taylor-example"]
    },
    {
      "@type": "WebPage",
      "@id": "https://www.thespoke-example.com/knowledge-base/e-bike-battery-care#webpage",
      "url": "https://www.thespoke-example.com/knowledge-base/e-bike-battery-care",
      "name": "E-bike battery care: how to make it last longer",
      "isPartOf": { "@id": "https://www.thespoke-example.com/#website" },
      "breadcrumb": { "@id": "https://www.thespoke-example.com/knowledge-base/e-bike-battery-care#breadcrumbs" },
      "inLanguage": "en-GB"
    },
    {
      "@type": "BreadcrumbList",
      "@id": "https://www.thespoke-example.com/knowledge-base/e-bike-battery-care#breadcrumbs",
      "itemListElement": [
        {
          "@type": "ListItem",
          "position": 1,
          "name": "Home",
          "item": "https://www.thespoke-example.com/"
        },
        {
          "@type": "ListItem",
          "position": 2,
          "name": "Knowledge base",
          "item": "https://www.thespoke-example.com/knowledge-base"
        },
        {
          "@type": "ListItem",
          "position": 3,
          "name": "E-bike battery care"
        }
      ]
    },
    {
      "@type": "Article",
      "@id": "https://www.thespoke-example.com/knowledge-base/e-bike-battery-care#article",
      "headline": "E-bike battery care: how to make it last longer",
      "image": "https://www.thespoke-example.com/images/e-bike-battery.jpg",
      "datePublished": "2026-09-01T09:00:00+01:00",
      "dateModified": "2026-10-10T14:30:00+01:00",
      "inLanguage": "en-GB",
      "mainEntityOfPage": { "@id": "https://www.thespoke-example.com/knowledge-base/e-bike-battery-care#webpage" },
      "author": { "@id": "https://www.thespoke-example.com/about-us/sam-taylor#person" },
      "publisher": { "@id": "https://www.thespoke-example.com/#organization" }
    }
  ]
}

A few choices in this example are deliberate:

1. Fixed @ids. Each entity gets one identifier, and other entities refer to it. That way there is one organisation, not five separate copies.
2. Specific subtype. BicycleStore is a subtype of LocalBusiness and says more than Organization alone.
3. Author as Person. The article refers to a real person with their own page and a sameAs.
4. Dates with a time zone. datePublished and dateModified are in ISO 8601 format.

On a real site, you keep the organisation and website on every page, or at least on the homepage, while the page, breadcrumb and article entities change per URL.

#Which pitfalls do you run into most often?

Most problems with schema markup arise because the markup claims something different from the page, or because it can't be read technically.

Markup that doesn't match the visible content. In its general structured data guidelines, Google says you must not mark up content that readers can't see, and that structured data must be a true representation of the page. A price, rating or opening time in JSON-LD that isn't visible anywhere is a mistake. In case of a violation, a page can lose its eligibility for rich results through a manual action.

Syntax errors. One missing comma or one quotation mark too many makes the whole block unreadable. Also watch out for commas after the last item in a list, which aren't allowed in JSON.

Only a homepage schema. Many sites have an Organization block on the homepage and nothing else. Articles without an author and date and product pages without a price then leave the most concrete facts unstated.

Missing sameAs. Without sameAs, your organisation is a name without a reference. Especially with a common company name, a link to your LinkedIn, company registration or Wikidata page makes the difference between being recognised and being confused with someone else.

Markup that only appears via JavaScript. Google can read JSON-LD that is added with JavaScript. You can't assume every AI crawler does too. So preferably put markup directly in the HTML the server delivers, using server-side rendering.

Expecting valid markup to solve everything. In the same guidelines, Google writes that it doesn't guarantee structured data will appear in search results, even if the test passes. Markup is a tool for making facts unambiguous. Neither is a file like llms.txt a cure-all: these are additions to good, accessible content.

#How do you validate schema markup?

You validate schema markup with two free tools: Google's Rich Results Test and schema.org's Schema Markup Validator. They check different things, so use both.

In its introduction to structured data, Google also mentions the URL Inspection tool in Search Console to check whether Google has found your structured data, and the rich result reports to track errors after publication.

#How to check this on your own site

1. Open the source code of your homepage (not the inspector, but "view page source") and search for application/ld+json. If nothing is there, your server isn't delivering JSON-LD in the raw HTML.
2. Check that there is an Organization or LocalBusiness block with name, logo, address and a sameAs list.
3. Open an article and a product page. Check that Article has an author and both dates, and that Product contains a price in the right currency that matches the visible price.
4. Paste the URLs into the Rich Results Test and the Schema Markup Validator and fix all errors.
5. Compare every value in the markup with the visible text. Anything that isn't on the page comes out of the markup.

Flowproof's free scan checks which JSON-LD types your pages contain, whether sameAs is present and whether the content is in the raw HTML, alongside the other technical GEO elements.