Schema Markup and llm.txt: How AI Search Engines Read and Cite Your Business

AI search engines like ChatGPT and Perplexity rely on structured summaries to answer questions accurately, and two very different mechanisms feed them those summaries: schema markup, embedded invisibly in a page's HTML, and llm.txt, a separate plain-text file built specifically for machine readers. Most discussions about AI search visibility treat these as interchangeable, but they solve different problems, and understanding both is what actually determines whether a business listing gets cited or quietly skipped.

What schema markup does

Schema markup is structured data - usually written as JSON-LD - embedded in a page's HTML that explicitly labels what each piece of content means. Instead of an AI system reading a paragraph and guessing whether a phrase is a business name, a service, or a customer review, schema markup tags it directly: this is the `name`, this is a `Service`, this is a `Review` with a numeric `rating`. It's the same structured data that has powered rich results in Google Search for years, and it's now doing double duty as the primary way large language models extract reliable facts from a page during a crawl or a real-time search. Google's own structured data documentation has described this pattern for traditional search results specifically for years, well before AI assistants started relying on the same markup.

The schema types that matter for a business listing

For a typical service business, three schema types cover almost everything an AI assistant needs: `LocalBusiness` or `Organization` for the business itself, `Service` for each offering, and `FAQPage` for anticipated buyer questions. A listing with all three gives an AI system a complete, unambiguous picture without it having to infer anything from surrounding prose.

What llm.txt actually is (and what it isn't)

llm.txt is a much newer, simpler idea: a plain-text file, served at a predictable URL, that summarizes a page's key facts in a format built for machines rather than browsers. It's conceptually similar to a sitemap or a robots.txt file - not something a human visitor is meant to read, but something an AI crawler can fetch quickly instead of parsing an entire rendered HTML page. It isn't a replacement for schema markup; it's a companion to it. Schema markup lives inside the page an AI system might already be reading. llm.txt exists for the case where a crawler wants the facts without the overhead of rendering the page at all.

Why llm.txt exists when schema markup already does this

The honest answer is redundancy and speed. Not every AI crawler renders JavaScript-heavy pages the same way, and not every crawl budget allows for parsing a full page just to extract a few facts. A dedicated plain-text file removes any ambiguity about how to fetch or interpret those facts - there's no HTML to parse, no JSON-LD to locate inside a script tag, just structured plain text at a known path.

How llm.txt works on a Yaeris Directory listing

On this directory, every approved business gets its own llm.txt file at `/company/[slug]/llm.txt`, generated live from the same database row that powers the visible listing page - not a separate, manually maintained document that can drift out of date. It includes the business name, its category, a description, and the names of its approved services and software, pulled fresh on every request. If the vendor has direct-link mode enabled, their live website URL is included too, giving an AI crawler a path straight to the source rather than just the directory's summary of it.

What gets included, and what's deliberately left out

The file is intentionally narrow. It only surfaces services and software that have themselves been approved - a pending submission doesn't appear in llm.txt any more than it appears on the public listing page, which keeps the two views of the same business honest with each other. Nothing in llm.txt claims anything the visible page doesn't already claim; it's the same facts, formatted for a different reader.

How to check that both signals are actually working

Neither schema markup nor llm.txt is visible on the page itself, which is exactly why they're so often left broken without anyone noticing. Checking schema markup takes two steps: view the page source (not the rendered page) and search for a script tag with `type="application/ld+json"`, then paste that block into Google's Rich Results Test to confirm it parses without errors. Checking an llm.txt file is simpler still - it's just a URL, so visiting `/company/your-slug/llm.txt` directly in a browser should return plain text with your business name, category, description, services, and software, not a 404 or an empty page. If either check comes back empty, the underlying listing data is incomplete, not the technical feature.

Setting up your own listing for both signals

If you're a vendor wondering whether your own listing is doing everything it can here, the practical checklist is short. First, make sure your business description and service names are complete and specific rather than generic - both schema markup and llm.txt only surface what's actually in the underlying data, so a thin listing produces thin machine-readable output no matter how well the technical plumbing works. Second, get your services and software approved rather than left pending, since unapproved items are excluded from both the schema markup on your page and your llm.txt file. Third, if you have a direct website, enable direct-link mode so AI crawlers - and human readers - have a path to your own site, not just the directory's summary of it.

Common mistakes that keep AI crawlers from citing a business

The most common failure isn't a missing technical feature - it's incomplete data feeding a technically correct system. A listing with `Service` schema markup but no actual service descriptions filled in still produces empty or generic-sounding facts. An llm.txt file with a business name and category but no description gives a crawler almost nothing to work with. The second most common mistake is inconsistency: a business description on the visible page that doesn't match what's summarized in schema markup or llm.txt undermines the exact consistency signal that answer engine optimization depends on. Fixing both is less a technical project than an editorial one - it just requires actually filling in the listing completely.

A third, less obvious mistake is treating either signal as a one-time setup task. A business that adds two new services six months after listing but never gets them approved is quietly widening the gap between what it actually offers and what its schema markup and llm.txt file both say. Since both are generated live from the same underlying data rather than a static file written once and forgotten, the fix is simply keeping the listing itself current - there's no separate machine-readable document to remember to update in parallel.

Why this matters more as AI search grows

The volume of buying research that starts with a question typed into an AI assistant, rather than a search engine results page, keeps climbing, and that shifts where the return on this kind of work actually shows up. A business that's easy for an AI system to read accurately gets described accurately when a prospective customer asks about it - the right services, the right category, a working link back to the real site. A business that's hard to read accurately either gets left out of the answer entirely or gets described in vague, generic terms that don't distinguish it from any other vendor in the same category. Schema markup and llm.txt are the two levers a business actually controls in that outcome; the rest comes down to simply keeping the underlying listing complete and current.

How different AI crawlers actually use these two signals

Not every AI system reads a page the same way, which is part of why running both schema markup and llm.txt matters more than picking one. Some crawlers render a page's full HTML and JavaScript before extracting anything, in which case schema markup embedded in that rendered page is directly readable. Others operate under a tighter crawl budget or skip full rendering entirely, in which case a lightweight, predictable llm.txt file at a known path can get read even when the crawler never fully parses the visible page. Running both means a listing doesn't depend on guessing which approach any specific crawler takes - it's readable either way, which is the entire point of treating them as complementary rather than choosing one.

A quick self-check most vendors skip

Beyond the technical checks already covered, there's a simple content check worth doing on your own listing every few months: read your llm.txt file's output side by side with your visible listing page and ask whether a stranger reading only the plain-text version would come away with an accurate, complete picture of what your business actually does. If the llm.txt output feels thin - just a name and a category with nothing else - that's a signal the underlying listing data needs filling in, not that the technical feature is broken. This is worth repeating periodically rather than checking once at signup, since a listing that was complete at onboarding can quietly go stale as a business adds services it never gets around to formally submitting for approval.

If you want the fuller picture of how structured data, moderation, and consistency combine to make an entire directory (not just one listing) trustworthy to AI search tools, we've written that up separately in how answer engine optimization decides which directories get cited. If you're a vendor on Yaeris Directory, checking your own listing takes a few minutes and directly determines whether an AI assistant describes your business accurately or skips it entirely - review your listing if you're already registered, or get listed for free if you're not.