Schema Markup: What It Is and How It Works in SEO and AI Search

What Is Schema Markup?

Schema markup is a standardised vocabulary used to describe the contents of a page in a machine-readable format.

Rather than relying entirely on natural language processing to infer meaning from text, schema allows websites to communicate information explicitly through structured data.

The vocabulary itself lives at Schema.org, a collaborative project supported by Google, Microsoft, Yahoo, and Yandex.

It contains hundreds of schema types that can be used to describe people, organizations, products, services, articles, events, locations, and many other entities.

At a technical level, schema consists of explicit key-value pairs that describe the entities on a page and the relationships between them.

Take a look at the example below:

{
  "name": "John's Pizza",
  "address": "123 Main Street",
  "rating": 4.8
}

Here, "name", "address", and "rating" are the keys, while "John's Pizza", "123 Main Street", and 4.8 are the corresponding values. Together, these key-value pairs describe a business in a format that search engines can process and understand.

Entities and Disambiguation

This is one of the most important concepts in schema markup.

Modern search engines increasingly operate on entities rather than keywords. An entity is simply a thing that can be uniquely identified.

• You are an entity that can be described using Person schema.
• Your company is an entity that can be described using Organization schema.
• The products you sell can be described using Product schema.

Schema allows you to define those entities and explain how they connect to one another. This becomes particularly valuable when names are ambiguous.

Take the word "Apple." Without additional context, it could refer to the technology company, the fruit, or the record label. While humans are naturally able to resolve that ambiguity, machines need additional signals which is what schema provides.

In this case, if you declare an Organization called Apple Inc. and add a sameAs link pointing to its entry on Wikipedia or Wikidata, search engines can confidently identify the correct entity and connect it to their knowledge graph.

This process is known as entity disambiguation.

Note: sameAs references are particularly important because they help connect entities on your website to recognised versions of those same entities elsewhere on the web.

How Schema Markup Is Implemented

Schema markup can be implemented in three primary formats: JSON-LD, Microdata, and RDFa.

JSON-LD

JSON-LD (JavaScript Object Notation for Linked Data) is Google's recommended format and the one used for most modern implementations.

Instead of embedding structured data throughout your HTML, JSON-LD places everything inside a dedicated script block that sits separately from the visible page content.

In the example above, JSON-LD markup defines information such as the recipe name, author, image, ratings, and ingredients. Search engines can use this information to better understand the content and potentially display enhanced search features.

Microdata

Microdata adds schema directly to HTML elements using additional attributes.

Search engines support it, but it can become difficult to manage because the structured data is spread throughout the page markup rather than being kept in a single location.

RDFa

RDFa follows a similar approach by embedding structured data within HTML attributes.

While fully supported by search engines, it is less common in SEO implementations and is generally more complex to maintain.

For most websites, the decision is simple: use JSON-LD unless you have a specific technical reason not to.

How Search Engines Use Schema Markup

The most visible use of schema is rich results.

These are enhanced search listings that display additional information directly within the search results, such as:

• Review ratings
• Product pricing and availability
• Breadcrumb navigation
• Business information
• Event details

Here's a good example: someone searching for a keyword like "outdoor garden" is likely looking for products, inspiration, or solutions for their outdoor space.

Rather than showing only traditional blue links, Google can enhance the results page with supplementary information such as product images, prices, ratings, reviews, and availability.

This allows searchers to compare options directly from the search results before deciding which result to click.

Rich results can improve visibility and click-through rates, but they represent only part of schema's value. Even when a page contains valid structured data, Google may choose not to display a rich result.

Google has also stated that structured data is not a ranking factor. While some search features may rely on schema, particularly those that require specific information such as prices, availability, or event details, its primary purpose is to help search engines understand content rather than influence rankings directly.

This distinction matters because rich result features come and go.

Google has retired several structured-data-powered search features over the years, including FAQ rich results. Meanwhile, the markup itself remains valid, and the entity understanding it provides remains useful.

This is why it helps to think about schema as an entity layer, rather than as a tactic for earning a specific search feature.

Types of Schema

Schema.org contains hundreds of entity types, but most websites only need a small handful to cover the majority of their structured data needs.

Let’s explore some of the core schema types:

• Organization
• Person
• Product
• Service
• LocalBusiness
• Article (or WebPage)

Organization Schema

Organization schema identifies your brand as an entity, whether it’s a business, non-profit, or club. It typically lives on an About page and can be referenced across the rest of the website to connect content back to the organization behind it.

Person Schema

Person schema describes an individual, which makes it particularly useful for authors, reviewers, executives, and team members. It helps search engines understand who someone is and how they relate to other entities such as organizations, publications, and websites.

Product and Service Schema

Product and Service schema tell search engines that an entity can be purchased, booked, licensed, or otherwise acquired.

The distinction is straightforward:

• Use Product for physical goods and software products.
• Use Service for professional services, consulting, maintenance, subscriptions, and other intangible offerings.

These schema types can also describe important details such as pricing, availability, ratings, reviews, and providers.

LocalBusiness Schema

LocalBusiness is a specialised form of Organization schema designed for businesses with a physical location. If customers visit your premises, book appointments, or interact with a Google Business Profile, LocalBusiness schema is usually worth implementing.

It can be used to provide details such as business hours, addresses, phone numbers, geographic coordinates, and service areas.

Article and WebPage Schema

While Organization and Person schema describe entities, Article and WebPage schema describe the content itself.

For publishers, Article schema helps create explicit connections between content, authors, and organizations. It can also define important information such as headlines, publication dates, featured images, and publishers.

Schema Markup and AI Search: What the Evidence Shows

As AI-generated search experiences become more common, schema's role has become one of the most debated topics in SEO.

The question is not whether schema helps machines understand content, which it clearly does. The real question is whether adding schema increases how often AI systems cite your content.

One of the strongest pieces of evidence comes from an Ahrefs study that tracked 1,885 pages that added JSON-LD against 4,000 control pages. The study found no meaningful uplift in citations across AI Overviews, AI Mode, or ChatGPT.

The important nuance, drawn out in an analysis by Gianluca Fiorelli, is that the pages tested were already heavily cited, many carrying more than a hundred AI Overview citations before any schema was added.

Those are entities that AI systems could already identify with confidence. Because schema's primary role is to reduce ambiguity and improve understanding, there may have been little additional value for it to provide.

That leads to a more useful conclusion than simply saying "schema doesn't work." A fairer interpretation is that schema appears to have limited impact for entities that are already well understood.

There is another reason to be cautious about assuming AI systems parse schema exactly as intended. In a test by Mark Williams-Cook, a fake address was placed inside deliberately invalid JSON-LD using made-up schema types and properties. When asked for the company's address, both ChatGPT and Perplexity still returned the fake address.

In other words, the systems appeared to rely on the information they found on the page rather than validating whether the structured data itself was valid schema. This suggests that schema's value lies in helping systems understand a page, not in feeding them information they would otherwise be unable to find.

Google's own guidance points in a similar direction. It states that structured data is not required for generative AI search and that there is no special schema.org markup needed for AI-powered experiences. At the same time, Google continues to recommend structured data as part of a broader SEO strategy because it helps websites qualify for rich results.

Taken together, the message is fairly consistent. Schema helps search engines understand content, identify entities, and build richer representations of brands, people, and topics. What it does not appear to do is act as a direct ranking lever for AI-generated answers.

How to Implement Schema Markup (Practical Steps)

Let's look at some practical considerations for implementing schema markup.

Start with JSON-LD

For most websites, JSON-LD should be the default choice. Google recommends it because it keeps structured data separate from your visible page content, and it is significantly easier to maintain than inline formats such as Microdata or RDFa.

To do this, you can write it manually or generate it with a schema tool.

AI-generated schema can be a useful starting point, but it has the same weakness as any other generated code. It often looks correct even when important relationships, properties, or identifiers are missing. Watch out for that.

A purpose-built tool like SUBJCT helps here.

It generates schema inside its article editor, then resolves each entity to its Google Knowledge Graph entry and validates the output before you publish, so the identifiers and relationships are grounded and checkable instead of assumed.

Build a Connected Entity Graph

One of the most common schema mistakes is treating each piece of markup as an isolated block.

Search engines are not simply looking for an Organization, a Person, or a Product. They are trying to understand how those entities connect to one another. That is why it helps to think in terms of an entity graph.

Your organization sits at the centre. Authors connect back to that organization. Articles connect to authors. Products and services connect to the organization that provides them. Each relationship adds context and helps search engines build a more complete understanding of the entities involved.

Stable @id values play an important role here because they allow entities to reference one another instead of being repeatedly redefined.

Rather than creating a collection of disconnected schema blocks, you create a connected graph that mirrors the relationships that already exist within the business itself.

Validate and Maintain

Before anything ships, run it through two checks:

• The Schema Markup Validator catches syntax errors. Even a misplaced comma or bracket can prevent search engines from processing the markup correctly.
• Google's Rich Results Test confirms eligibility for rich results. If you see "no valid items detected," it does not necessarily mean your schema is broken. It may simply mean the markup is not eligible for a rich result.

As content changes, schema often becomes outdated. Regular audits help ensure your structured data remains accurate and continues to reflect the entities and relationships it was originally intended to describe.

How SUBJCT Automates Schema Generation and Knowledge Graph Linking

Everything discussed so far is relatively straightforward when you're working on a handful of pages.

The challenge emerges when those same standards need to be maintained across hundreds, thousands, or even millions of URLs. At that point, schema becomes a data management problem.

This is where automation becomes valuable, and it’s what SUBJCT is built to handle. Rather than treating schema as a citation trick, SUBJCT treats it as entity infrastructure, generated consistently and at scale.

Here’s how it works: Inside the article editor, SUBJCT makes it possible to generate a page's schema in a single action.

What it produces is a JSON-LD map of the entities a piece covers and how they relate, the kind of pre-parsed, disambiguated structure a search engine or LLM leans on when it has to find the relevant facts inside a source.

Each entity links to its Google Knowledge Graph entry, so it stops being a string the engine has to interpret and becomes a node it can resolve with confidence, which is the sameAs step from earlier handled for every entity in the piece.

Before anything ships, the markup can be validated without leaving the editor. The Validate Schema button copies the code and opens the Schema.org Validator, and the same code can run through Google's Rich Results Test for rich-result eligibility, which is the check that keeps broken schema off the page.

For a single article, the finished markup copies straight into your CMS. For larger libraries, the same generation runs across a whole archive through SUBJCT's templates and APIs, so the entity layer stays accurate as the site grows rather than drifting page by page.

As websites grow, the value of schema increasingly depends on whether entity relationships remain accurate across the entire site. Automating that process makes it easier to maintain a coherent entity layer without manually auditing every page.