Schema Markup for AI: The Entity Graph Explained

Search engines and AI assistants do not read your website the way a person does. A human glances at your homepage and understands in a second that you are a business, what you sell, and where you are. A machine sees a wall of HTML. Schema markup is how you hand that machine the facts directly, in a language built for the purpose.

This guide covers what schema markup is, what an entity graph adds on top of it, and how to build one. We use our own site, nexum-sol.com, as the worked example, because we rebuilt its entity graph recently and can show you the real thing.

What is schema markup?

Schema markup is a shared vocabulary, published at schema.org and supported by Google, Microsoft, and others, for labelling what things on a page actually are. You wrap your facts in agreed types (Organization, Person, Article) and properties (name, address, founder) so a machine reads them without inferring anything.

It almost always lives in a JSON-LD block, a small script in your page's HTML that carries the data separately from the visible design. Your visitors never see it. Crawlers read it first. Here is the smallest useful example, the block that tells a machine "this is a company, here is its name and website":

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Nexum-sol",
  "url": "https://nexum-sol.com"
}

That is already useful, but on its own it is a single, isolated fact. The power comes from connecting facts together, which is where the entity graph begins.

What is an entity graph?

An entity is a distinct thing: your company, your founder, a service, a page. An entity graph is those things plus the relationships between them, written so a machine reads one consistent identity across your whole site instead of scattered, unlinked facts.

Two properties do most of the work:

• @id gives each entity a unique, permanent address (a URL with a fragment like #organization). Define the entity once, then point to it by its @id everywhere else. No repetition, no contradiction.
• sameAs links your entity to its verified profiles elsewhere: LinkedIn, Google Business Profile, Crunchbase, Clutch. It is how a machine confirms the company on your site is the same company it sees across the web.

Our graph, in plain terms

On nexum-sol.com the Organization is the root entity, defined once with an @id. The founder is a Person linked back to it with worksFor. The four service lines hang off the Organization in an OfferCatalog. The site itself is a WebSite entity whose publisher points to the same Organization @id, and every blog post is an Article that points there too. One identity, referenced everywhere:

{
  "@context": "https://schema.org",
  "@graph": [
    { "@type": "Organization", "@id": "https://nexum-sol.com/#organization",
      "name": "Nexum-sol", "url": "https://nexum-sol.com",
      "sameAs": [ "https://www.linkedin.com/company/nexum-sol-ltd",
                  "https://clutch.co/profile/nexum-sol" ] },
    { "@type": "Person", "@id": "https://nexum-sol.com/#founder",
      "name": "Abdulmuiz Adebowale",
      "worksFor": { "@id": "https://nexum-sol.com/#organization" } },
    { "@type": "WebSite", "@id": "https://nexum-sol.com/#website",
      "url": "https://nexum-sol.com",
      "publisher": { "@id": "https://nexum-sol.com/#organization" } }
  ]
}

Notice the pattern: the Organization is defined once, and the Person and WebSite refer back to it by @id rather than repeating its details. We also added the company's registration number as an identifier and listed our verified profiles under sameAs. When we deployed it, we ran the whole thing through validator.schema.org and fixed it until it returned zero errors, because a block that does not parse does nothing at all.

Does this actually help AI find you?

Structured data does one thing well: it removes ambiguity. A machine no longer has to infer whether "Nexum-sol" is a company, a product, or a typo. It is told, in a format built for the purpose.

For traditional search, Google documents structured data as the basis for rich results, the enhanced listings with ratings, FAQs, and site details. For generative AI engines the influence is newer and best treated as "verify by observation" rather than a guarantee. What is not in doubt: clean, consistent entity data is the same raw material an AI needs to identify and describe a business accurately. It removes the guesswork that makes AI omit you or get you wrong.

Schema is a foundation, not a magic switch. It makes you easy to parse and easy to trust. Your content, your indexing, and your off-site mentions still do the rest. Anyone promising that a schema block alone will guarantee a ranking or an AI citation is overselling.

Which schema types should you use?

Match every type to something actually on the page. A sensible starting set for most businesses:

• Organization (or LocalBusiness for a physical location): your root entity. Name, URL, logo, contact, address, sameAs.
• WebSite: your site as an entity, with publisher pointing to the Organization.
• Person: your founder or key people, linked with worksFor.
• Service or OfferCatalog: what you sell.
• Article and FAQPage: on blog posts. The FAQ text in the schema must match the questions visible on the page.
• BreadcrumbList: your navigation path.

How do you check your schema is valid?

Deployed and valid are different states. Paste your URL into validator.schema.org or Google's Rich Results Test. They parse every block and report errors and warnings. Aim for zero errors before you rely on any of it. We learned this the direct way: our own homepage schema was invalid for a while because of a single missing comma, which meant every engine that read it discarded the whole block. It looked deployed. It did nothing.

A four-step start

You do not need the whole graph on day one. Build it in this order:

1. Add an Organization (or LocalBusiness) block to your homepage with your real name, URL, contact, and address.
2. Give it an @id, and add a WebSite entity that references it.
3. List your verified profiles under sameAs, and add a Person entity for your founder.
4. Validate at validator.schema.org until it returns zero errors, then keep it consistent as your site grows.

For the wider strategy this sits inside, see our pillar guide on SEO, AEO & GEO, and the audit that checks all of this on your own site, The AI Visibility Audit.

Frequently asked questions

What is schema markup?

Schema markup is a standard vocabulary of tags, defined at schema.org, that you add to your web pages to describe what things on the page actually are: a business, a person, a product, an article, a FAQ. It usually lives in a JSON-LD script in the page's HTML. Humans see a normal page; machines read the markup and understand the facts without guessing.

What is an entity graph?

An entity graph is a connected set of things (entities) and the relationships between them, expressed in structured data. On a website it means your Organization, its founder, its services, and its pages are each defined once with a unique @id and then linked to each other, so a machine reads one consistent identity across the whole site instead of scattered facts.

Does schema markup help with AI search like ChatGPT and Gemini?

Structured data makes your facts unambiguous and machine-readable, which is what AI engines need to identify and describe a business accurately. Google documents structured data as the basis for rich results. For generative AI engines the influence is still emerging and best verified by observation, but clean entity data removes the guesswork that causes AI to omit or misdescribe a business.

What schema types should a business use?

Start with Organization (or LocalBusiness) as your root entity, plus WebSite. Add Person for the founder, Service or OfferCatalog for what you sell, Article and FAQPage on blog posts, and BreadcrumbList for navigation. Connect them with @id references and list your verified profiles under sameAs. Match every type to something actually on the page.

How do I check if my schema is valid?

Paste your page or URL into validator.schema.org or Google's Rich Results Test. They parse every structured-data block and report errors and warnings. Deployed and valid are different states: a single missing comma can make a whole block invalid, so validate after every change and aim for zero errors before you rely on it.

Does schema markup guarantee better rankings or AI citations?

No. Schema markup helps machines understand your content; it does not force a ranking or a citation, and anyone promising guaranteed placement is overselling. It is a foundation that makes you easier to parse, identify, and trust, which improves your odds, but the content itself, your indexing, and off-site consensus still do the heavy lifting.

References & sources

1. Schema.org, the shared structured-data vocabulary, schema.org
2. Google Search Central, Intro to how structured data works
3. Google Search Central, Organization structured data
4. Schema.org, Schema Markup Validator