A woman in Charlotte opens ChatGPT and types "best endodontist near me for a cracked molar." She doesn't scroll ten blue links. She reads three sentences, sees two names, and calls the first one before lunch. Somewhere across town, a root canal specialist with fifteen years of practice and a wall of five-star reviews never comes up. Not ranked low. Not there. The AI didn't dislike him. It just couldn't confidently say who he was, so it named someone it could.
That gap between "excellent practice" and "practice an AI will vouch for" is where structured data lives now. And in 2026 it's doing something it never did in the old search era.
What schema actually does when an AI reads your page
Structured data is markup — usually JSON-LD, a small block of code sitting quietly in your page's source — that states facts about your business in a format machines don't have to interpret. Instead of an AI parsing a paragraph and inferring that you're a pediatric dentist in Charlotte open until six, you tell it directly, in a vocabulary (schema.org) that every major system already understands.
That sounds like a technical nicety. It isn't, and here's the mechanism that makes it matter. AI assistants don't take your website's word for anything. When ChatGPT, Claude, Gemini, Perplexity, Google AI Overviews, Grok, or Copilot decides whether to name you, it's not reading your site in isolation and being charmed. It's cross-checking. It looks for the same fact showing up the same way in more than one independent place, because agreement across sources is what turns a claim into something trustworthy instead of merely asserted. A model that finds your specialty, your location, and your name lining up across your own markup, your directory profiles, and third-party mentions grows confident. A model that finds your schema saying one thing and your Yelp page saying another gets cautious. And a cautious model hedges. It hands the recommendation to whoever's story is clean.
So schema isn't a ranking trick. It's you speaking the machine's language clearly enough that when it goes to verify you, the first thing it reads doesn't contradict everything else. We went deeper on the reasoning behind this in how LLMs decide who to recommend, and it's worth reading if the "why" here feels abstract.
The types that carry weight in local verticals
There's a family of schema types built for exactly this. Local business markup and its more specific children — the ones that let a dentist declare Dentist rather than generic LocalBusiness, or a firm declare LegalService rather than "some company" — do real work because specificity is itself a trust signal. A model reading "Dentist" knows more about what to verify and where to verify it than a model reading a vague catch-all.
Then there's markup that turns your content into something an AI can lift directly. A well-marked-up question and answer, sitting on a service page, is the closest thing there is to feeding a model a sentence it can quote back to a user. When a prospective client in Denver asks Perplexity how long a probate case takes in Colorado, an assistant would much rather cite a clean, attributed answer than paraphrase a wall of prose and risk getting it wrong. That's the appeal. The trap is assuming the markup does the persuading. It doesn't. It makes good answers legible; it makes bad answers legibly bad.
There's more in this family — types for services, for the practitioner as a person, for how multiple offices relate to one parent organization, for author attribution on the articles you publish. Each one exists to state a specific kind of fact cleanly. But listing them out and telling you to go implement all ten in order would be handing you a to-do list that misses the entire point, which is that markup only helps to the degree it's true and corroborated. Ten valid schema types on a business whose facts don't agree with each other across the web is ten clean statements of a confusing story.
Why one directory is worth understanding in depth
Take Martindale-Hubbell, if you're an attorney. It's easy to dismiss as an old-guard legal directory, the kind of listing lawyers set up in 2011 and forgot. But watch what it does inside an AI's verification process and you'll see why a stale one is quietly dangerous.
Martindale is old, which in this context is a feature. It has been rating and listing lawyers for well over a century, its peer-review ratings are cited across the legal profession, and — this is the part that matters to a model — its data gets syndicated and referenced widely enough that an AI encounters your Martindale identity in multiple places without you doing anything. When an assistant is deciding whether to name you as, say, a family law attorney in Austin, a consistent Martindale presence acts as one of the independent corroborations it's hunting for. Your site says you're a family lawyer in Austin. Your Martindale profile, indexed and echoed across the web, says the same. The model's confidence ticks up. Not because Martindale is magic, but because it's an independent voice saying what you already said.
Now flip it. You moved offices in 2023. Your website updated. Martindale didn't. An AI cross-checking your address finds a contradiction — your own markup and a century-old authority disagreeing about where you practice. The model can't tell which is right, so it does the safe thing and stops short of a confident recommendation. The very asset that could corroborate you is now the thing introducing doubt. That's the whole lesson in one example: an authoritative source pointing the wrong direction is worse than no source at all, because it's credible wrongness, and credible wrongness is exactly what makes a model hedge.
Understand Martindale that way and you understand the entire category. It was never about the directory. It was about whether the independent voices describing you agree.
Where implementations quietly fail
Most schema problems aren't missing markup. They're markup that lies without anyone meaning to lie. A practice picks the wrong type — tags itself as a generic organization when it's a medical clinic, so the AI never gets the specificity it needs to verify a specialty. Or two competing schema blocks end up on the same page, each asserting slightly different facts, and the model reading them gets exactly the contradiction that makes it retreat. Or, most common of all, the markup was accurate the day it went live and has been slowly going stale ever since — a phone number from two providers ago, a doctor who left, a Saturday hour you stopped offering.
Validation catches the syntax. Google's Rich Results Test and the schema.org validator will both tell you if your JSON-LD is malformed. Neither will tell you it's wrong — that your valid, well-formed markup confidently asserts an address you left last spring. That kind of error passes every validator and fails the only reader who matters. We covered the foundations of getting this right in schema markup for AI search, and the wider strategy in the generative engine optimization guide.
What this looks like when you measure it
The uncomfortable part of GEO is that you usually can't see it happening. Traditional analytics platforms and rank tracking tools show you clicks and positions. They don't show you the conversation where an AI weighed you against two competitors and picked the other two, because that conversation happens inside a model, in a private session, and never touches your server.
This is why we built the AI Visibility Index — a benchmark drawn from thousands of real AI answers evaluated across verticals and platforms, with the sample sizes disclosed rather than hand-waved. What it consistently shows is that the businesses AI names aren't always the biggest or the oldest. They're the ones whose story holds together when a model goes looking. The gap between "great practice" and "AI-recommended practice" is real, it's measurable, and it's often shockingly fixable once you can actually see it.
Your competitor might already be the answer
Here's what to sit with. Right now, today, an AI assistant is answering the exact question your best future client would ask. And it's giving them a name. If that name isn't yours, it's someone else's — a practice down the road that isn't necessarily better than you, just legible in a way you aren't yet. Every one of those answers is a client who was ready to call, handed to somebody else before you knew the conversation happened. Not a slow decline. A specific person, a specific need, routed away in three sentences you'll never see.
You built this practice over years. It shouldn't lose ground in a channel you can't even watch. RankCommander's scan shows you what all seven assistants — ChatGPT, Claude, Gemini, Perplexity, Google AI Overviews, Grok, and Copilot — actually say when someone asks for what you do, where your story contradicts itself, and where a competitor is standing in the spot that should be yours. What separates the practices winning here isn't a longer checklist than everyone else's — it's that they found out what the machines were saying before their competitors did. Run your scan and stop guessing whether you're the name.