AI Search Aug 21, 2026 12 min read by No Time For SEO

The Schema Markup a Small Business Needs for AI Search

Schema markup for AI search needs 4 types: Organization, LocalBusiness, FAQPage, Service. 22,143 AI crawler hits/week, with copy-paste JSON-LD.

A small business does not need the twelve schema types the agency blogs list. It needs four, done right: Organization, LocalBusiness, FAQPage, and one revenue type (Service or Product). Get those four correct and keep the markup matching what a visitor actually sees.

  • Four types cover a small business. Organization and LocalBusiness establish identity and place; FAQPage and Service earn answers and recommendations.
  • JSON-LD is the format. AI systems parse structured data, not your visible paragraphs alone.
  • Matching beats volume. Markup that contradicts the visible page gets distrusted and dropped.
  • Schema is a prerequisite, not a promise. It makes you eligible for citation; content quality still decides.

In the week of Monday, July 27, 2026, No Time For SEO logged 22,143 AI crawler and agent hits across the 8 business sites we track in server logs. Those bots were not admiring your design. They were extracting facts, and schema is how you hand the facts over cleanly.


What is schema markup, and how is it different from regular SEO?

Schema markup is structured data: a block of code that labels the facts on your page so a machine can read them without guessing. It uses a fixed vocabulary from schema.org that AI systems and search engines parse directly.

  • Regular on-page SEO writes for a human scanning the text, inferring meaning from sentences.
  • Schema markup restates those same facts in a labeled format a machine never misreads.

The practical difference is trust and speed. A person infers your hours from a sentence. A machine reads "opens": "09:00" and is certain. That certainty is why structured data feeds knowledge graphs and AI Overviews while plain prose often does not.

Tip: Use JSON-LD, not microdata. Google recommends JSON-LD as the preferred structured data format, and it sits in one script block instead of being tangled through your HTML, so it is far easier to keep correct.

Schema does not change what your page says. It restates your page in a language machines never misread, and that is the whole job.


What schema types does ChatGPT use to understand my business?

ChatGPT does not publish a list of schema types it reads, so anyone claiming an insider ranking formula is guessing. What we can say honestly is that ChatGPT, Perplexity, and Google AI Overviews are different systems, and each consumes structured data to identify a business, its location, its answers, and its services.

We can measure who is reading. The table below shows one week from our own logs, split by user-agent, so you can see which systems actually fetch pages and how often.

User-agent What it does Hits that week
chatgpt-user Live page reads when ChatGPT answers a real person 3,983
ClaudeBot Anthropic crawl (training and indexing) 3,566
PerplexityBot Perplexity index crawl 825
GPTBot OpenAI training crawl 563
All AI crawlers and agents tracked Every AI user-agent we match in logs 22,143

Table 1. One week of AI crawler and agent hits across the 8 sites No Time For SEO tracks (week of Monday, July 27, 2026).

Where these numbers come from: No Time For SEO matches AI user-agents (GPTBot, ClaudeBot, PerplexityBot, OAI-SearchBot, chatgpt-user, meta-ai, amazonbot, bingbot) in raw nginx server logs across the 8 business sites we manage, then totals them weekly. These counts are one measured week. They show who reads our pages, not who cited them; citation is measured separately.

The takeaway is specific: chatgpt-user, the live agent ChatGPT uses to read a page while answering a question, fetched our tracked pages 3,983 times in that week, more than any single training crawler. In the same week, training crawlers hit those sites 4,129 times (GPTBot 563, ClaudeBot 3,566) versus 825 PerplexityBot hits. The facts on your page have to be machine-readable now.


Type 1: Organization schema, your identity foundation

Organization schema is the node that tells AI systems who you are. Every other schema type on your site should point back to this one node, because it is the anchor for your entity in a knowledge graph.

  • name, url, logo for the core identity.
  • contactPoint for phone and contact type.
  • sameAs links to the profiles AI systems already trust.

Copy this starting block, replace the values, and keep the structure intact.

<script type=”application/ld+json”>
{
“@context”: “https://schema.org”,
“@type”: “Organization”,
“@id”: “https://yourbusiness.com/#organization”,
“name”: “Your Business LLC”,
“url”: “https://yourbusiness.com/”,
“logo”: “https://yourbusiness.com/logo.png”,
“sameAs”: [
“https://www.facebook.com/yourbusiness”,
“https://www.linkedin.com/company/yourbusiness”
],
“contactPoint”: {
“@type”: “ContactPoint”,
“telephone”: “+1-555-123-4567”,
“contactType”: “customer service”
}
}
</script>

The sameAs array matters more than it looks. It connects your site to the profiles the wider web already knows, which is one way ChatGPT and Perplexity confirm the business you claim to be is the business they can verify elsewhere.


Do I need LocalBusiness schema for AI search?

If you have a physical location or serve a defined area, yes: LocalBusiness schema is required, because it carries the facts AI systems use for local answers. A pure online business with no location can skip it and lean on Organization instead.

  • address and openingHours for where and when.
  • areaServed for the region you cover.
  • paymentAccepted for how customers pay.

LocalBusiness extends Organization, so use a specific subtype when one fits, such as Dentist, Plumber, LegalService, or Restaurant. The more specific the type, the less an AI system has to infer.

<script type=”application/ld+json”>
{
“@context”: “https://schema.org”,
“@type”: “Dentist”,
“@id”: “https://yourbusiness.com/#localbusiness”,
“name”: “Your Business LLC”,
“parentOrganization”: { “@id”: “https://yourbusiness.com/#organization” },
“address”: {
“@type”: “PostalAddress”,
“streetAddress”: “123 Main St”,
“addressLocality”: “Austin”,
“addressRegion”: “TX”,
“postalCode”: “78701”
},
“openingHours”: “Mo-Fr 09:00-17:00”,
“areaServed”: “Austin, TX”,
“paymentAccepted”: “Cash, Credit Card, Insurance”
}
</script>

One warning trips up most owners: the hours in this block have to match the hours a visitor reads on the page. When markup and visible content disagree, AI systems distrust the markup.


Does FAQPage schema increase AI citations?

FAQPage schema does not increase AI citations by itself, but it is the schema type most directly aligned with how AI tools extract answers, because it stores content as the exact question-and-answer pairs those tools lift.

  • It matches the extraction unit. A clean question and answer is a ready-made snippet for ChatGPT or Perplexity to quote.
  • It mirrors real phrasing. Questions written the way customers type them line up with the queries AI systems fan out.

A single researched article No Time For SEO wrote for a 5-location dental group earned 52,171 Google impressions in one month while ranking on page one, measured in July 2026, and it was built on tight question-and-answer structure.

Watch out: No Time For SEO measures crawler hits and Search Console outcomes, not a controlled before-and-after citation-lift test from FAQ markup alone. We show reach here, not a causal claim that FAQ markup by itself raises citations.

Format your FAQ as real questions a customer types, keep each answer under 75 words in the phrasing people actually use, and make sure every question and answer is visible on the page.

<script type=”application/ld+json”>
{
“@context”: “https://schema.org”,
“@type”: “FAQPage”,
“@id”: “https://yourbusiness.com/faq/#faqpage”,
“publisher”: { “@id”: “https://yourbusiness.com/#organization” },
“mainEntity”: [{
“@type”: “Question”,
“name”: “Do you accept dental insurance?”,
“acceptedAnswer”: {
“@type”: “Answer”,
“text”: “Yes. We accept most major PPO plans and file claims for you.”
}
}]
}
</script>

Does Service and OfferCatalog schema help AI recommend my services?

Service schema is what moves you from a known business to a recommendable one, because it states what you sell, to whom, and where in a form ChatGPT and Perplexity can match against a person’s request.

Tip: Add an OfferCatalog when you offer several distinct services, so each one is its own labeled item rather than a paragraph an AI system has to parse.

When someone asks for a plumber who does emergency repairs in Austin, that request is matched against structured service facts, not loose prose.

<script type=”application/ld+json”>
{
“@context”: “https://schema.org”,
“@type”: “Service”,
“provider”: { “@id”: “https://yourbusiness.com/#organization” },
“areaServed”: “Austin, TX”,
“hasOfferCatalog”: {
“@type”: “OfferCatalog”,
“name”: “Services”,
“itemListElement”: [
{ “@type”: “Offer”, “itemOffered”: { “@type”: “Service”, “name”: “Emergency Leak Repair” } },
{ “@type”: “Offer”, “itemOffered”: { “@type”: “Service”, “name”: “Water Heater Installation” } }
]
}
}
</script>

If you sell products or collect reviews instead, swap in Product and Review or AggregateRating as your fourth type. Your fourth block should describe the thing that makes you money.


Connecting the four types with @id into one entity graph

The single step most small business schema skips is linking the blocks with @id. Without it, an AI system reads four unrelated snippets; with it, LocalBusiness, FAQPage, and Service all reference the same Organization node and collapse into one coherent business entity.

You saw the pattern in the code above: give Organization a stable @id, then point parentOrganization, publisher, and provider back to it. That is how you build one entity graph instead of four loose objects.

Schema type What it tells AI systems Priority for a small business
Organization Legal name, logo, contact, sameAs profiles Required (the anchor node)
LocalBusiness Address, hours, service area, payment Required if you have a location or service area
FAQPage Direct question-and-answer pairs to lift High
Service (+ OfferCatalog) What you sell, to whom, where High if you want to be recommended

Table 2. The four-type minimum for a small business, in build order. Everything beyond this list is optional until these four are correct and connected.


Should I write inline JSON-LD or use a plugin for schema?

Use a plugin if your site runs on a CMS that has a good one, and write inline JSON-LD only when no schema plugin manages your pages. The decision is about avoiding duplicate, conflicting schema, not about which method is purer.

  1. Check whether your SEO plugin (RankMath, Yoast) already outputs Organization and Article schema. Most do.
  2. Configure the plugin’s schema settings instead of pasting a second inline block, so you never ship two Organization nodes with different values.
  3. Write inline JSON-LD only for what the plugin does not cover, or when no plugin is active on the site.
  4. Verify after publishing that exactly one Organization and one Article or BlogPosting entity exists. Two means a conflict.

Conflicting schema is worse than no schema. When two blocks claim different hours or different names, Google and AI systems treat the contradiction as a low-quality signal against the whole page.


Validate with Google’s Rich Results Test before you publish

Never publish schema you have not validated. Google’s Rich Results Test parses your markup exactly as a machine does and shows every field it read, so you catch a broken block before an AI system ever sees it.

  1. Open the Rich Results Test at search.google.com/test/rich-results.
  2. Paste your live URL, or the raw code with the Code tab for a page not yet published.
  3. Read the detected items and confirm each type (Organization, LocalBusiness, FAQPage, Service) appears with the values you expect.
  4. Fix every error and warning, then re-test until the report is clean.
  5. Cross-check the parsed values against the visible page so markup and content agree field by field.

Passing the validator confirms your syntax is correct. It does not confirm an AI system will cite you, and it does not check whether your markup matches the page, so that last check stays on you.


How to verify AI actually reflects your schema (and how long it takes)

Passing the validator is step one; confirming AI systems reflect your business is the step no competitor guide covers, and it means checking the actual answers, not just the code.

  1. Ask ChatGPT and Perplexity direct questions your business should answer, such as “who does emergency plumbing in Austin”, and note whether the business name appears.
  2. Search Google for a query that triggers AI Overviews and watch for your business in the generated answer.
  3. Watch your server logs for chatgpt-user and PerplexityBot hits on the updated page, which confirm the systems fetched it.
  4. Repeat the probes weekly, because a single check on a single day tells you almost nothing.

Expect weeks, not minutes. ChatGPT, Perplexity, and Google AI Overviews re-fetch and re-index on their own schedules, so a schema change shows up gradually rather than overnight.

Tip: For the answer-checking part, see our guide on how to check if ChatGPT recommends your business, and for the selection mechanics, how AI chatbots choose which business to recommend.

Common schema mistakes that make AI systems distrust you

Most failed schema is not missing schema; it is wrong or contradictory schema. These are the four errors we see most, and each one is fixable this week.

  • Markup that does not match the visible page. Hours or prices in the code that differ from the page. AI systems distrust the mismatch and drop the facts.
  • The wrong schema type. Tagging a service page as Organization, or a blog post as Product. The type has to describe what the page actually is.
  • Missing @id links. Four disconnected blocks instead of one entity. Connect them so AI systems read one business.
  • Duplicate conflicting blocks. A plugin and an inline block both defining Organization with different values. Keep one source of truth.

Schema is not a set-and-forget task. When your hours, address, prices, or reviews change, the markup has to change with them, or the match that used to be an asset becomes the exact error above.

Tip: Put a recurring schema check on the calendar the way you would for a business listing. For the bigger picture, see why ChatGPT does not know your business exists and what answer engine optimization is.

Your do-this-now schema checklist

Run this in order. A busy owner can finish it in a week, one block per sitting.

  1. Add Organization schema with a stable @id, logo, contact, and sameAs profile links.
  2. Add LocalBusiness schema (a specific subtype) with address, hours, service area, and payment, if you have a location.
  3. Add a FAQPage block built from real customer questions, each answer under 75 words and visible on the page.
  4. Add Service with an OfferCatalog (or Product and Review) as your revenue-driving fourth type.
  5. Link all four with @id so they reference one Organization node.
  6. Validate every block in Google’s Rich Results Test and fix all errors.
  7. Match each markup field against the visible page, line by line.
  8. Probe ChatGPT, Perplexity, and Google AI Overviews weekly, and give it a few weeks to show.
Tip: No Time For SEO helps owners implement and monitor this end to end, so if schema is not something you want to hand-code, that is a service we sell. Either way, the four-type checklist above is yours to run today, free.

Frequently asked questions

What percentage of AI-cited pages use structured data?

No one has published a percentage you should trust, and anyone quoting a precise figure is guessing at data only the AI companies hold. From our own logs, across the 8 sites No Time For SEO tracks, AI crawlers and agents made 22,143 fetches in the week of July 27, 2026. Structured data makes those fetches useful; it does not, by itself, buy a citation.

Is schema markup enough to get cited by ChatGPT?

No. Schema markup is a prerequisite for citation, not a promise. It makes your facts machine-readable, which makes you eligible. Whether ChatGPT cites you still depends on content quality, authority, and whether your page answers the question better than the alternatives. Anyone promising a locked-in citation is overselling.

Do I really only need four schema types?

For most small businesses, yes. Organization, LocalBusiness, FAQPage, and one revenue type (Service or Product) cover identity, place, answers, and offers. The enterprise stacks with a dozen types add complexity a small business rarely needs. Get these four correct and connected before adding anything else.

How long until AI systems reflect my new schema?

Plan for weeks, not instant results. ChatGPT, Perplexity, and Google AI Overviews re-fetch and re-index on their own schedules, so schema changes appear gradually. Watch your server logs for fresh crawler hits on the updated page, and re-run your answer probes weekly rather than expecting an overnight change.

Should I use inline JSON-LD or a plugin?

Use a schema plugin if your CMS has a solid one, and configure it rather than pasting a second inline block. Write inline JSON-LD only for what the plugin does not cover, or when no plugin manages your site. Running both for the same type creates conflicting values, which Google and AI systems treat as a low-quality signal.

Want your business named in answers like these?

Send us your website. In two business days you get a free, human written report on where you show up on Google and in AI answers, and what we would fix first.

Get your free audit