If you have started optimizing for AI search, you have probably heard about llms.txt, a plain-text file that hands large language models a clean, curated map of your site. The idea is simple, the spec is short, and adoption has moved fast among documentation and developer-tool companies. What is harder to find is a straight answer to two questions: what does a good llms.txt actually look like, and is it worth your time. This guide answers both. Below are ten real, live llms.txt examples you can open right now, a plain-English breakdown of the format, a step-by-step on how to write one, and an honest take on what it will and will not do for your visibility in ChatGPT, Perplexity and Google’s AI answers. No hype, no vendor spin, just what the file is, who is already using it well, and how to ship a genuinely good one within the week, with no guesswork.

Quick Answer

llms.txt is a Markdown file placed at your domain root (yoursite.com/llms.txt) that gives AI models a concise, curated index of your most important pages, in a format they can read without wading through your navigation, ads and scripts. It was proposed by Jeremy Howard of Answer.AI in September 2024. The best real-world examples, from Cloudflare, Stripe and Perplexity, share one pattern: an H1 title, a one-line summary, and tidy sections of Markdown links to the pages that matter. To write your own, list your highest-value URLs with short descriptions, host the file at your root, and add a companion llms-full.txt with the full text. One caveat up front: no major AI provider has publicly confirmed it consumes llms.txt as a ranking signal yet, so treat it as low-cost, forward-looking hygiene rather than a guaranteed traffic lever.

What is llms.txt, exactly?

llms.txt is a proposed standard for a single Markdown file, served at your site root, that tells a language model which pages on your site matter and what each one covers. Jeremy Howard, co-founder of Answer.AI and creator of the fast.ai courses, published the proposal in September 2024. The reasoning is practical: an AI model that lands on a normal web page has to parse menus, banners, cookie notices and JavaScript to find the actual content, and it often runs out of context window before it gets there. A curated index in clean Markdown removes that friction and points the model straight at your best material. You can read the specification itself at llmstxt.org, which, fittingly, publishes its own llms.txt.

It is easy to confuse with two files it is not. It is not robots.txt, which tells crawlers what they may and may not fetch; llms.txt does the opposite, actively inviting models to the content you want seen. And it is not a sitemap.xml, which lists every URL for search-engine crawlers; llms.txt is a short, human-curated shortlist written for reasoning models, not an exhaustive machine dump. Many sites also publish a second file, llms-full.txt, which inlines the full text of the linked pages into one long document so a model can ingest everything in a single request. If you want the broader picture of how AI engines choose sources, our guide to answer engine optimization sets the context.

The short history: why this file appeared when it did

The proposal landed in September 2024, and the timing was not an accident. Retrieval-augmented AI tools were exploding, every one of them needed to read websites, and they were all hitting the same wall: a modern page is mostly wrapper. Navigation, cookie banners, analytics scripts and design markup can outweigh the actual answer by an order of magnitude, and a model with a finite context window burns most of it on noise before it reaches the substance. Jeremy Howard’s insight was that the fix did not require the AI companies to build anything; site owners could simply publish a clean, curated version of what matters and let any model use it.

Documentation and developer-tool companies adopted first, for an obvious reason: their users were already pasting docs into AI assistants, so making that content machine-legible had immediate, visible value. The curve steepened when documentation platforms began generating the file automatically for every site they host, which is why so many live examples share a near-identical shape. Community directories now catalogue thousands of published files, and a lively debate runs alongside the growth about whether the big engines will ever formally consume it. That debate is unresolved, but the publishing side has already voted with its feet, and the effort to produce one is small enough that waiting for a verdict has little upside.

10 real llms.txt examples worth studying

The fastest way to learn the format is to read files that are already live. Every example below returned a valid file when we checked it, and each shows a slightly different way to use the standard. Open a few side by side and the pattern becomes obvious.

1. llmstxt.org (the reference)

The spec’s own site publishes the canonical llms.txt. It is the cleanest illustration of the format: an H1, a blockquote explaining the proposal, then short sections of annotated links. If you only read one file before writing your own, read this one.

2. Cloudflare

Cloudflare’s developer docs expose a large, well-sectioned llms.txt covering products, tutorials and reference. It is a good model for a big documentation estate: the links are grouped by product area so a model can navigate to the right corner quickly.

3. Stripe

Stripe’s docs.stripe.com/llms.txt opens with a practical instruction to models about installing Stripe packages, then indexes the developer documentation. It shows that the file can carry a little guidance, not just links.

4. Perplexity

Fittingly for an answer engine, Perplexity’s docs publish a compact llms.txt with a one-line summary and a tidy API reference index, a good template for a focused, single-product site.

5. Mintlify

Mintlify matters twice over. It publishes its own llms.txt, and, because it is a documentation platform, it auto-generates the file for the many docs sites it hosts. A large share of the llms.txt files you find in the wild exist because a team chose Mintlify, not because they hand-wrote one.

6. ElevenLabs

The ElevenLabs docs show the standard applied to an AI product with SDKs across several languages, sectioning the links so a model can find the right language quickly.

7. Zapier

Zapier labels its file a local index for developer documentation. Its llms.txt is a reminder that the audience is a machine building an answer, so the descriptions are terse and literal, not marketing copy.

8. Supabase

Supabase points its llms.txt at the complete documentation in a single file, leaning on the llms-full.txt idea so a model can pull everything at once, useful for a deep, interlinked reference.

9. Svelte

The Svelte file is explicitly titled documentation for LLMs and is a clean example from an open-source framework rather than a commercial docs platform, proof the format is not only for vendors.

10. Bun

The JavaScript runtime Bun keeps a straightforward, link-first llms.txt that maps its docs. It is a good minimal example to copy if your site is mostly reference material. Other strong live files worth a look include ClickHouse and Expo.

Read four or five of these and you will notice the same skeleton every time. That skeleton is the whole standard, and it is what the next section walks through.

llms.txt vs robots.txt vs sitemap.xml

Three small files sit at your site root and get muddled constantly, so it is worth pinning down what each one is for. Robots.txt is a permission layer: it tells automated crawlers which paths they may or may not fetch, and it has been part of the web since 1994. It says nothing about what your content means; it only draws boundaries. A sitemap.xml is a discovery layer: it lists every URL you want indexed, along with metadata like last-modified dates, so a search engine can find and schedule your pages. It is exhaustive and written for machines that crawl at scale.

The new file is a comprehension layer, and that is the difference that matters. Rather than listing every page or gating access, it hands a reasoning model a short, ranked, human-curated tour of the content that actually answers questions, in the clean Markdown those models parse most reliably. A crawler still uses your robots and sitemap; a language model building an answer benefits from the curated index. The three are complementary, and a mature site publishes all three. Think of robots.txt as the fence, sitemap.xml as the phone book, and the curated index as the concierge who walks a guest straight to the right room.

How to write an llms.txt file, step by step

The format is deliberately small. You can hand-write a solid llms.txt in an afternoon, and the steps below match what every example above is doing.

1. Start with an H1 and a one-line summary

The first line is a single H1 with your site or project name. Immediately below it, add a blockquote (a line beginning with >) that summarizes what the site is in one sentence. Models use this as the headline context for everything that follows, so make it specific and plain.

2. Group your best pages into H2 sections

Under H2 headings such as Docs, Guides or API, list your highest-value pages as Markdown bullet links in the form - [Page title](https://full-url): short note on what it covers. Curate ruthlessly. This is a shortlist of the pages you most want cited, not a copy of your sitemap. If you are deciding what belongs, the same judgment that drives good schema markup for AI citations applies here: lead with the pages that answer real questions.

3. Add an Optional section for the rest

The spec reserves a section titled Optional for links a model can skip when it is short on context. Put lower-priority material there so the model spends its budget on what matters first.

4. Publish a companion llms-full.txt

Where llms.txt is the index, llms-full.txt is the full book: the complete text of your key pages concatenated into one Markdown file. Sites like Supabase lean on this so a model can ingest everything in one fetch. Generate it from your existing content rather than writing it by hand.

5. Host it at your root and keep it fresh

Serve the file at yoursite.com/llms.txt with a text/plain or text/markdown content type. Treat it like any other living asset: when your key pages change, regenerate it. If your docs run on a platform such as Mintlify, this happens automatically; otherwise a small build script or plugin can regenerate it on deploy.

A copy-paste llms.txt template

If you want a starting point, the skeleton below follows the spec exactly. Replace the placeholders with your own pages, keep the descriptions short and factual, and delete any section you do not need. Everything after each link colon is a note to the model about what the page covers.

# Your Company
> One clear sentence describing what your site or product does.

## Docs
- [Getting started](https://example.com/docs/start): first steps for a new user
- [API reference](https://example.com/docs/api): endpoints, auth and rate limits
- [Authentication](https://example.com/docs/auth): how to obtain and use API keys

## Guides
- [Core concepts](https://example.com/guides/concepts): the mental model in plain language
- [Common workflows](https://example.com/guides/workflows): the tasks most users need

## Optional
- [Changelog](https://example.com/changelog): release notes and version history
- [Pricing](https://example.com/pricing): plans and limits

Save that as a plain-text file named llms.txt, host it at your root, and you have a valid file. From there, the work is curation: the quality of the pages you choose to list, and how honestly you describe them, is what makes the difference between a file a model finds useful and one it ignores.

Which AI tools actually read llms.txt today?

Adoption on the publishing side has clearly outrun adoption on the consuming side, and being straight about that matters. On the publishing side, thousands of sites now ship the file, driven heavily by documentation platforms generating it by default. On the consuming side, the picture is mixed. Several coding assistants and agent frameworks can be pointed at a project’s file to load documentation context, and a number of research and retrieval tools use it when ingesting a site. Some answer engines are experimenting with it as one input among many.

What is not established is guaranteed, automatic use by the big general-purpose engines. Neither OpenAI nor Google has documented reading it as a standard step, and Google has signalled doubt in public. The realistic read for 2026 is that the file helps most in agent and developer-tool contexts today, and represents a cheap option on wider adoption later. That asymmetry, near-zero cost now, plausible upside later, is the whole case for publishing one even while the standard is young. If proving impact matters to you, the only reliable answer is to measure your AI citations before and after and watch the trend.

The clearest present-day value shows up in the developer-tool world, and it is worth understanding because it hints at where the rest may go. When an engineer points a coding assistant or a retrieval agent at a product, a curated index lets the tool load the right documentation instead of scraping and guessing, which produces noticeably better answers about that product. That is precisely why developer-first companies rushed to publish, and why the files you find in the wild skew so heavily toward APIs, SDKs and technical docs. If the general-purpose engines follow, the sites that already maintain a clean, current file will be first in line to benefit, with no scramble required. If they do not, those same sites have still made their content easier for the tools their customers use every day. Either way the file earns its keep, which is a rare thing to be able to say about an emerging standard this young.

Five common llms.txt mistakes to avoid

Because the format is so simple, most errors are errors of judgment rather than syntax. These are the ones that show up most often in files we review.

• Dumping the whole sitemap. The point is curation. A file with four hundred undifferentiated links is no more useful to a model than your raw navigation. List the pages you most want cited.
• Writing marketing copy in the descriptions. The reader is a machine assembling an answer. Terse, literal notes about what each page covers beat persuasive taglines every time.
• Letting it go stale. A file that points at deleted or renamed pages actively misleads a model. Regenerate it when your content changes, ideally as part of your deploy.
• Skipping llms-full.txt. The index is useful, but the companion full-text file is what lets a model ingest your content in one pass. If you can generate it, do.
• Treating it as a ranking hack. It is content hygiene, not a shortcut. Sites that expect a traffic jump from the file alone are usually disappointed; the lift comes from the underlying content the file points to.

Your llms.txt launch checklist

Before you ship, run through this list. It captures what the live examples above get right and the mistakes they avoid, and it works as a quick audit for a file you already have.

• Root placement: the file resolves at yoursite.com/llms.txt and returns plain text, not an HTML error page or a redirect chain.
• Clear H1 and summary: the first line names the site, and the blockquote explains it in one sentence a stranger would understand.
• Curated, not exhaustive: you listed the pages you most want cited and left the rest out, or pushed them into the Optional section.
• Honest descriptions: each note says plainly what the page covers, with no taglines or persuasion aimed at a human buyer.
• Absolute URLs: every link is a full https address, so a model reading the file on its own can resolve each one without guessing your domain.
• Companion full-text file: a matching llms-full.txt exists and is generated from the same source content, not maintained separately by hand.
• A refresh plan: something regenerates both files when your content changes, so they never point at pages you have deleted or renamed.

Tick all seven and you have a file that stands with the best examples in this guide, and one that is ready for whatever the engines decide to do with the standard next.

Where llms.txt fits in a modern AEO strategy

It is tempting to treat a new file as a new strategy. It is not. Getting cited by AI engines still rests on the same foundations it always has: content that genuinely answers the questions your buyers ask, the credibility signals that make a model trust you, structured data it can extract cleanly, and an internal architecture that connects related pages. This file is a thin, helpful layer on top of that foundation, not a substitute for it. Publish it, keep it current, and then put your real energy where the citations are actually won.

In practice that means three things run in parallel. First, the content itself has to be worth citing, which is a question of depth and originality, not file formats. Second, the machine-readable signals, from schema markup to this index, have to be clean and consistent so a model can parse you without guessing. Third, you have to know whether any of it is working, which is why measurement is not optional; if you are not watching how often you appear in AI answers, you are flying blind. Teams that treat the file as one tidy tactic inside that larger system get value from it. Teams that expect it to carry the whole strategy do not. That is the same lesson our clients learn about every individual AEO tool: the tool is only as good as the content and the discipline behind it.

Who should prioritize this, and who can wait

Not every site needs to rush. The businesses that get the most out of the format today are the ones whose audiences already lean on AI tools to navigate their content: software and API companies, documentation-heavy products, and any brand whose buyers ask assistants technical questions before they buy. If your users are pasting your pages into ChatGPT or wiring your docs into an agent, a clean index and full-text file pay off immediately, because those tools read them now.

If you run a small local business or a simple brochure site, the honest advice is to keep it in proportion. Generate the file if your platform makes it trivial, but do not lose a week hand-crafting one while your core pages still lack the depth and credibility signals that actually earn citations. The sequence that works for almost everyone is the same: fix the content first, add the machine-readable layers including this one, then measure. Publishing the file is a twenty-minute job once your content is right, and it is premature before it is. For most teams the smart move is to ship a basic version now, because it costs almost nothing, and revisit it properly once the pages it should point to are genuinely worth citing.

Does llms.txt actually help you get cited?

Here is the part most vendor listicles skip. As of now, none of the major AI providers, OpenAI, Google or Anthropic, has publicly confirmed that its crawlers or models read llms.txt as an input, and Google’s Search Advocate John Mueller has publicly compared its current status to the keywords meta tag, something sites publish that search engines do not necessarily use. So the honest position is that llms.txt is a community-driven, forward-looking standard, not a proven ranking lever.

That said, the cost is close to zero and the upside is real. The file is trivial to generate, it cannot hurt you, and the exercise of curating your most important pages into clean Markdown is genuinely useful for the tools that do read it today, plus any that adopt it tomorrow. It also pairs naturally with the work that already moves the needle in AI search: strong E-E-A-T signals, the structured data that answer engines extract, and a clear content architecture. If you want to know whether any of it is working, you have to track your brand’s AI citations over time, because that measured lift, not the presence of a file, is the real scoreboard. For the bigger picture of which domains AI engines lean on, see our breakdown of the most-cited websites in AI answers.

Our own view, from running generative engine optimization programs for clients: publish a clean llms.txt and llms-full.txt because they are cheap and future-proof, but spend the real effort on the content and authority signals that already earn citations. If you want help doing both, that is exactly what our answer engine optimization team does, and you can compare the tooling in our roundup of the best AEO and GEO tools.

Frequently asked questions

Is llms.txt the same as robots.txt?

No. Robots.txt tells crawlers what they are allowed to fetch, while llms.txt actively points AI models toward the pages you most want read. One is a gate, the other is a guided tour, and they can coexist.

Do ChatGPT, Perplexity or Google actually use llms.txt?

As of now, none of the major providers has publicly confirmed it uses llms.txt as a ranking or retrieval signal, and Google has been openly skeptical. Some AI dev tools and agents do read it. Treat it as low-cost, forward-looking hygiene rather than a guaranteed traffic source.

Where do I put the llms.txt file?

At your domain root, served at yoursite.com/llms.txt as plain text or Markdown, exactly like robots.txt sits at the root. Every live example in this guide follows that convention.

What is the difference between llms.txt and llms-full.txt?

llms.txt is the curated index of links to your key pages. llms-full.txt is the full text of those pages concatenated into one file, so a model can ingest all of your content in a single request.

Do I have to write llms.txt by hand?

Not necessarily. Documentation platforms such as Mintlify generate it automatically, and for other stacks a small build script or plugin can produce it from your existing content on every deploy.

Will llms.txt help my SEO rankings in Google?

It is not a confirmed ranking factor for traditional search. Its purpose is helping AI models understand and cite your content. The things that still drive rankings, quality content, E-E-A-T and structured data, matter far more, and llms.txt complements them rather than replacing them.