Structured Data and Schema for Google Gemini: How to Speak the AI's Language

By Jin Grey, Senior SEO Consultant ·Updated July 15, 2026 ·22 min read

What structured data is and why Gemini uses it

Structured data is a standardised, machine-readable summary of your page. It does not change a single word a human reads. Instead, it sits alongside your content and labels it in a shared vocabulary: this text is the headline, this name is the author, this block is a question and its answer, this number is a price. When Google and Gemini read that summary, they no longer have to infer your facts from prose. You have told them plainly.

Think of a page as a paragraph a stranger reads aloud. A human can usually tell which sentence is the author's name and which is the publish date from context. A machine reading millions of pages cannot afford to guess, and guessing is exactly what lowers its confidence. Structured data is the label maker that removes the guessing. It is the difference between hoping the model understood you and knowing it did.

Gemini cares about this more than classic search ever did, and the reason is simple. Classic ranking could show your link and let the reader decide. Gemini writes the answer itself and attaches a source to it, so it has to be sure before it quotes you. A wrong citation reflects on Google. Anything that helps the model confirm a fact quickly — who said it, when, in what context, backed by what identity — makes your page safer to repeat. Structured data is one of the cleanest ways to provide that confirmation.

This article is the technical companion in our Gemini series. If you have not yet read the foundation, start with the complete Google Gemini SEO guide, then come back here for the markup layer. And if your content itself still needs work, the content optimization guide covers the writing side. Schema amplifies good content; it cannot rescue thin content, so the order matters.

One honest caveat before we go deeper: structured data is not a magic switch. It will not lift a page that is blocked, slow, or empty. What it does is remove ambiguity from a page that already deserves to be cited, which is often the last few percent that decides whether Gemini picks you or a competitor. Treat it as the finishing layer on solid work, not a shortcut around it.

JSON-LD vs. microdata, and why JSON-LD wins

There are three ways to add structured data to a page: JSON-LD, microdata, and RDFa. For almost every site in 2026, the answer is JSON-LD, and it is worth understanding why so you never waste time on the alternatives.

Microdata and RDFa are inline formats. You weave attributes like itemprop directly into your visible HTML, wrapping each piece of content in extra tags. It works, but it tangles your markup with your layout. Every redesign risks breaking it, the attributes are hard to read, and a single misplaced tag can quietly invalidate a whole block without any visible sign.

JSON-LD takes the opposite approach. It lives in one self-contained <script> block, usually in the head, completely separate from your visible HTML. You describe your page as a small, tidy object of key-value pairs. Because it is isolated, you can add it, edit it, and validate it without touching your design, and a developer can read the whole thing in one glance.

Google states directly in its structured data documentation that JSON-LD is the recommended format. That alone settles it for most publishers. The whole rest of this guide uses JSON-LD, and if you learn only one format, this is the one. The build-it-cleanly instinct here is the same one we teach in AI Vibe Coding: keep concerns separated so your work stays easy to change.

There is a practical bonus to the JSON-LD approach for small teams. Because the markup is one block, you can template it. Write the shape once, swap the headline, author, and dates per page, and you have consistent structured data across your whole site without hand-editing every layout. That repeatability is what turns schema from a chore into a habit.

The core schema types and what each confirms

Schema.org defines hundreds of types, but you do not need most of them. A short list carries almost all the value for content and business sites. The trick is to match the type to what your page actually is, because each type confirms a specific set of facts. The Schema.org Article reference is a good example of how each type documents its expected properties.

Here is the working set, with what each one tells Gemini and when to reach for it.

Notice a pattern: every type is really a promise about a fact. Article promises a real author and date. Product promises a price. Review promises a rating. Gemini treats those promises as confirmations it can lean on, which is precisely why they raise your citation odds. The types you choose should mirror the truth of the page, never decorate it.

If you are just starting, do not try to add all nine at once. Begin with Article, Organization, and Person, because they establish who is behind the page — the trust layer Gemini reads first. Add FAQPage and HowTo when your content genuinely takes those shapes. Save Product, Review, and LocalBusiness for commercial and local pages. This staged approach is exactly how students build markup in the AI SEO course track, one confirmed fact at a time.

A minimal Article and FAQPage example

Talking about schema is easier than reading it, so here is a minimal, valid example you can adapt. This is what a small Article block looks like in JSON-LD. Notice that it is just a labelled description of the page — nothing more mysterious than that.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "How to Verify Your AI Vibe PH Certificate",
  "datePublished": "2026-07-15",
  "dateModified": "2026-07-15",
  "author": {
    "@type": "Person",
    "name": "Jin Grey",
    "url": "https://jingrey.com"
  },
  "publisher": {
    "@type": "Organization",
    "name": "AI Vibe PH",
    "logo": {
      "@type": "ImageObject",
      "url": "https://aivibeph.com/logo.png"
    }
  }
}
</script>

Read it top to bottom in plain English. The context says we are speaking Schema.org. The type says this is an Article. Then we confirm the headline, the dates, the author with a link to their identity, and the publisher with a logo. A machine now knows six facts about the page with zero guessing. That is the entire point of structured data in one small block.

Now a FAQPage block, which is the type most likely to feed an AI answer directly, because it already matches the question-and-answer shape Gemini reuses. Every question and answer here must also appear as visible text on the page.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Do I need schema to appear in AI Overviews?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "No, but it helps Gemini confirm your facts and reduces misreads, which raises your citation odds."
      }
    }
  ]
}
</script>

Two details are worth calling out. First, the answer text in the markup is identical to the answer a reader sees on the page. That match is not optional; it is a rule, and breaking it is treated as spam. Second, you can extend the mainEntity array with as many questions as you genuinely show. On this very page, the FAQ at the bottom is mirrored in the real schema in exactly this pattern, which you are free to view in the source as a live reference.

One more note on the escaping you see above. In these examples the angle brackets and braces are written as HTML entities so they display as code instead of running as a real script. On your own page, you would use the real characters inside a genuine script tag. If that sounds fiddly, it is the kind of detail we walk through hands-on in the AI Vibe PH masterclass, where students add working schema to real Filipino sites.

Connecting entities with @id and sameAs

This is where structured data stops being a checklist and starts being a strategy. Two properties — @id and sameAs — let you connect the entities across your whole site so Gemini reads one consistent identity instead of scattered fragments. Entity clarity is the deep skill behind AI SEO, and these two properties are how you express it in markup.

Start with @id. It is a unique identifier, almost always a URL, that names an entity so you can reference it from anywhere. Define your author once as a Person with an @id like https://aivibeph.com/#jin-grey, and every article can point to that same id instead of redescribing the author. Gemini then understands that all those pages share one author entity, not fifty lookalikes. That is how a byline accumulates authority across a site.

Now sameAs. It points from your entity to other authoritative profiles for the same person or brand — a LinkedIn page, a personal website, an official Facebook page. Those links help the model match your identity to a known reference across the web. When your Person entity says sameAs a real LinkedIn profile and a personal site, you give Gemini corroboration, and corroboration is what turns a name into a trusted source.

Here is the mental model. @id connects entities inside your site into one map. sameAs connects that map outward to the wider web. Together they let Gemini confirm not just what your page says, but who is saying it and whether that identity is real elsewhere.

You can see this pattern in action in the source of this page. The Person entity carries a stable @id and a sameAs list that includes the author's own site at the AI Vibe PH about page level of consistency across the series. Building that entity map deliberately is the same content-architecture discipline we lay out in the keyword-to-brief workflow — you are teaching the model a tidy graph of who and what, not a pile of pages.

Schema for local and commerce: LocalBusiness, Product, Review

Content sites are not the only ones Gemini cites. Shops, service providers, and local businesses can be pulled into AI answers too, and for a business those citations are often the most valuable because the searcher is close to buying. The commerce schema types are how you confirm the facts a buyer and a model both want.

Three types do most of the work for commercial pages:

• LocalBusiness confirms your name, address, opening hours, and service area, which is what Gemini needs for near-me and city-level queries.
• Product confirms a product's name, price, currency, availability, and specifications, so the model can state accurate details in an answer.
• Review and AggregateRating confirm reputation — the star rating and the number of reviews behind it — which is powerful for trust-driven searches.

For a Filipino audience this matters more than most guides admit. Big international sites are usually thin on local specifics: peso pricing, barangay-level service areas, and Taglish product descriptions. If a Cebu bakery marks up its products with peso prices and its LocalBusiness details with real hours and address, Gemini has clean facts to quote for a local buyer that a global competitor simply cannot provide.

Two rules keep commerce schema safe. First, the price, availability, and rating in your markup must match what the page shows a customer right now; stale or invented numbers are a guideline violation. Second, never mark up reviews you did not genuinely collect. Fake ratings are the fastest way to lose trust with both Google and buyers. If you want a second opinion on a commercial page before you publish, you can always contact the AI Vibe PH team for a review.

Done honestly, commerce markup turns a plain product page into a page a shopping-related AI answer can quote with your real prices and ratings attached. That is a booking or a sale delivered at the moment of decision, which is why we treat commercial schema as a core skill and not an afterthought in the course library.

How to add JSON-LD to a page, step by step

Let's make this concrete. Adding JSON-LD to a page is a short, repeatable process once you have done it a couple of times. Here is the sequence I use, whether the site is hand-coded or built on a CMS.

1. Identify the page type. Decide what the page really is — an article, a product, an FAQ, a local business — because that determines your schema types.
2. List the facts to confirm. Write down the author, dates, headline, price, questions, or address you want the model to be sure about.
3. Write one JSON-LD block. Create a single <script type="application/ld+json"> block and, if you have several types, wrap them in a @graph array.
4. Connect the entities. Give your author and organisation stable @id values and reference them, so the block reads as one coherent identity.
5. Match the visible page. Confirm every fact in the markup — every FAQ answer, every price — appears in the text a reader sees.
6. Validate before publishing. Run the block through a validator to catch broken JSON or missing required fields.
7. Publish, then test live. Deploy the page, check it in the Rich Results Test, and confirm it in Search Console once indexed.

On a CMS like WordPress, a good SEO plugin can generate much of this automatically, which is fine for standard Article and Organization data. The place plugins fall short is entity connection and custom types, so it is worth knowing the raw JSON-LD even if a tool writes the basics for you. Understanding what the tool produces is what lets you fix it when it is wrong.

Keep one habit above all: one block, validated, matching the page. Most schema problems come from either splitting markup across many messy blocks or from letting the markup drift out of sync with the content. If you template the block and validate every time, you avoid nearly every common failure. This is the same ship-it-then-verify loop we practise across the 10-task AI SEO strategy.

Which schema helps AI Overviews most

Not every schema type pulls the same weight for AI Overviews. Some directly match the shapes Gemini reuses, while others quietly build the trust and identity layer underneath. Knowing the difference tells you where to spend your first hour.

The highest-leverage types for AI answers are the ones that mirror how the model presents information. FAQPage matches the question-and-answer format almost exactly. HowTo matches step-by-step answers. Article confirms authorship and freshness, which the model checks before trusting a claim. Organization and Person build the identity that makes any citation safe. The commerce types matter enormously, but only for the commercial and local queries they describe.

The practical order for most sites is clear. Add Article, Organization, and Person everywhere to establish trust and identity. Add FAQPage and HowTo on the pages that genuinely take those shapes, since they most directly feed answers. Then layer commerce schema onto your money pages. That sequence puts your effort where the citation odds move most.

Resist the temptation to over-mark. Adding schema types that do not describe your page does not help and can trigger errors. The goal is not maximum markup; it is accurate markup on the pages where it counts. A focused article with clean Article and FAQPage data beats a cluttered page stuffed with types it does not need, every time.

Validating and testing your markup

Structured data you never validate is a quiet risk. A single missing comma can break an entire block, and you would never see it on the page. Validation is a two-minute habit that saves you from invisible failures, so build it into every publish.

Three tools cover almost everything you need:

• Google's Rich Results Test tells you whether your page is eligible for rich results and flags errors and warnings specific to Google.
• The Schema.org validator checks your markup against the vocabulary itself, catching structural problems regardless of Google.
• Search Console's enhancements reports show how your live pages are performing across your whole site, not just one URL.

Use them in that order. Before publishing, paste your code or URL into the Rich Results Test and the Schema.org validator to catch syntax errors and missing required fields. After publishing, watch Search Console over the following weeks to confirm Google is reading the markup on your live pages and to catch any errors that appear at scale. Google's own Search Essentials documentation is the authoritative reference whenever a tool flags something you do not understand.

Watch the difference between errors and warnings. Errors mean the markup is invalid or ineligible and must be fixed. Warnings usually mean a recommended field is missing — not fatal, but worth adding, because a more complete entity gives Gemini more to confirm. Clear every error first, then improve the warnings as time allows.

One last testing habit is easy to skip and worth keeping: after your page is indexed, actually prompt Gemini and Google with the question your page answers and see whether you are cited. Markup that validates is necessary but not sufficient; the real scoreboard is whether the model quotes you. Track that over weeks, the same way you would track any AI visibility metric, and you close the loop between markup and results.

Schema mistakes and how to fix them

Most schema problems fall into three buckets: invalid, mismatched, and spammy. Each one either wastes your effort or actively damages trust, and each has a straightforward fix. Clear these before you chase anything advanced.

The mismatched-markup mistake deserves special attention because it is both common and dangerous. Google is explicit that structured data must describe the content visible on the page. If your FAQPage markup lists answers that are not shown to readers, or your Product markup states a price the page does not display, that is a violation that can get your markup ignored or your site penalised. The rule is simple: mark up what you show, and show what you mark up.

The spammy mistakes are the ones that feel clever and end badly. Inflating ratings, marking up content only crawlers see, or stuffing types that do not apply might seem like a shortcut to rich results. In practice, these are exactly the patterns Google's systems are built to catch, and a lost citation is the least of the consequences. Honest markup is not just the ethical choice; it is the only one that survives. The best safeguard is a habit, not a trick — validate, match the page, and stay honest, and schema will only ever help you.

Your structured-data checklist

Before you publish or update any page you want cited, run it through this checklist. It gathers everything above into a single pass you can repeat until it becomes automatic.

Keep this list next to you until the moves become second nature. After a few dozen pages you will template the block, connect the entities, and validate without thinking, and that instinct is what steadily builds a site Gemini can read, trust, and quote. Markup is a small habit with a compounding payoff.

If you only do one thing from this whole guide, add clean Article and Organization markup with a real, connected author and publisher. That single step establishes the identity Gemini reads before it trusts anything else on the page. Everything after — FAQPage, HowTo, commerce types, sameAs links — raises your odds further, but authorship and identity are where every markup pass should begin. When you are ready to go further, browse the course library, join a live cohort on the events page, or verify how we practise what we teach through our certificate verification system, all built on the same principles you just read.

Frequently asked questions

Jin Grey

Senior SEO Consultant · AI SEO Strategist · 18+ years

Jin Grey helps businesses earn visibility across Google Search and AI-powered engines like Gemini, ChatGPT, and Perplexity. He leads the AI SEO track at AI Vibe PH and writes more at jingrey.com.