# llms.txt Validator — Full Content
> A fast, free tool to validate an llms.txt file against the official specification, verify that every linked URL is reachable, and get clear recommendations on how to improve it. This file inlines the full guide content.
Validator: https://llms-txt-validator.dev/ · Generator: https://llms-txt-validator.dev/generate · API: https://llms-txt-validator.dev/api/validate?url=example.com · A2A: https://llms-txt-validator.dev/.well-known/agent-card.json
---
# How to create an llms.txt file
> A practical, step-by-step guide to writing a spec-compliant llms.txt file: the H1 title, summary, sections, links, and where to host it.
An llms.txt file takes about ten minutes to write. This guide walks through every part, in order, and ends with a file you can paste and adapt.
## 1. Start with the H1 title
The first line must be a single H1 — the name of your project or site. It is the *only* strictly required element of the format.
```
# Acme Docs
```
## 2. Add a blockquote summary
Right under the title, add a one- or two-sentence blockquote. This is the context a language model reads first, so make it specific: what the site is and who it's for.
```
> Acme is a payments API. This file links to the docs an LLM needs to integrate and debug Acme.
```
## 3. (Optional) Add a few lines of prose
Before any section heading you may add plain paragraphs with extra orientation. Don't use headings here — keep it to a sentence or two.
## 4. Group your links under H2 sections
Each section is an H2 heading followed by a markdown list. Every item is a link with an optional description after a colon.
```
## Docs
- [Quickstart](https://acme.com/docs/quickstart): Integrate in five minutes
- [API reference](https://acme.com/docs/api): Every endpoint and parameter
## Examples
- [Sample app](https://acme.com/examples/app): A working end-to-end example
```
Use **absolute https URLs**, and keep descriptions focused on what a developer or model needs — not marketing copy.
## 5. Use the "Optional" section for nice-to-haves
A section literally named `## Optional` has special meaning: its links can be skipped when a shorter context is needed. Put changelogs, blog posts, and secondary references here.
## 6. Host it at the root
Serve the file at `https://yourdomain.com/llms.txt` with `Content-Type: text/plain`. Large sites often also publish a [llms-full.txt](/guide/llms-full-txt) with the full expanded content.
## 7. Validate before you ship
Paste your domain into the [validator](/). It checks the structure, confirms every link actually resolves, and lists exactly what to fix. Aim for 100/100.
---
# llms.txt vs robots.txt vs sitemap.xml
> These three files look similar but do completely different jobs. Here's exactly what each one controls and why llms.txt is not an access-control file.
All three live at your site root and all three are plain text — but they solve different problems. Mixing them up is the most common llms.txt mistake.
## The one-line summary
- **robots.txt** — controls *crawler access*: what bots may or may not fetch.
- **sitemap.xml** — lists *every indexable page* for search engines.
- **llms.txt** — curates a *shortlist of high-signal pages* for large language models at inference time.
## robots.txt is about permission
robots.txt tells crawlers which paths they're allowed to request. It is an access-control convention. It does not curate or rank content, and it isn't written for language models specifically.
## sitemap.xml is about coverage
A sitemap aims to be exhaustive: it maps all the URLs you want indexed so search engines don't miss anything. It's machine-oriented XML, not a human-readable summary.
## llms.txt is about curation
llms.txt is the opposite of exhaustive. It's a hand-picked, Markdown list of the few pages that best help a model understand and use your site — with a short description on each. It exists for *inference* (helping when a user asks an AI for help), not for training datasets and not for access control.
## They complement each other
You don't choose between them — a strong setup has all three. robots.txt governs access, sitemap.xml ensures coverage, and llms.txt curates signal for AI. Once you've written yours, [run it through the validator](/) and read [how to create an llms.txt file](/guide/how-to-create-llms-txt) for the format details.
---
# What is llms-full.txt?
> llms-full.txt is the full-content companion to llms.txt. Learn when to publish one, how it differs, and how big sites like Anthropic and Vercel use both.
If llms.txt is the table of contents, llms-full.txt is the whole book. The 2026 best practice is to publish both.
## The two-file pattern
llms.txt gives a model a compact, linked overview — it has to fetch each link to read more. llms-full.txt embeds the complete content of those pages directly in a single file, so a model can ingest everything in one request with no extra fetches.
## When to publish llms-full.txt
- You have documentation that benefits from being read in full (APIs, SDKs, guides).
- You want agents to work offline-ish, without crawling dozens of pages.
- You already maintain Markdown sources you can concatenate.
Tools like `llms_txt2ctx` can expand an llms.txt into a full version automatically.
## Don't forget per-page .md versions
The spec also suggests offering a clean Markdown version of each page at the same URL with `.md` appended (and `index.html.md` for directory URLs). That gives models a parse-friendly copy of any single page.
## Who does this
The llms.txt + llms-full.txt pairing is used by Anthropic, Vercel, and other documentation-heavy projects: the index for orientation, the full dump for deep ingestion.
## Check yours
Our [validator](/) reports whether a sibling llms-full.txt exists when you check a domain. New to the format? Start with [how to create an llms.txt file](/guide/how-to-create-llms-txt).
---
# Does llms.txt help SEO?
> llms.txt won't change your Google rankings directly. Here's what it actually does, why it matters for AI answers, and when it's worth your time.
Short answer: llms.txt does *not* directly boost your Google rankings. Its job is different — and increasingly important.
## What llms.txt does not do
Google has said llms.txt is not a ranking signal, and Googlebot doesn't use it for classic search. So if someone promises "add llms.txt and rank #1," be skeptical. It's not a meta tag, not a sitemap replacement, and not a backlink.
## What it actually does
llms.txt curates the pages you most want a language model to read when it's answering a question about your product or docs. As more answers come from AI assistants (ChatGPT, Claude, Perplexity, Google AI overviews), being cleanly readable by those models — "GEO," or generative engine optimization — is the new visibility game. A tidy llms.txt:
- points models at your best, most current pages instead of letting them guess,
- provides clean context so answers about you are accurate,
- pairs with Markdown versions of pages so models parse content, not nav and ads.
## So is it worth it?
If your audience asks AI tools about your domain — docs, APIs, products — yes. It's a small file with real upside and no downside. If you're a purely local business with no documentation, the payoff is smaller.
## Do this instead of chasing rankings
Treat llms.txt as one part of AI-readiness alongside the things that *do* help discovery: clean [robots.txt for AI crawlers](/guide/llms-txt-vs-robots-txt), schema.org structured data, and a sitemap. Then [validate your llms.txt](/) to make sure it's correct and every link resolves.
---
# Adding llms.txt to WordPress
> Three ways to publish a spec-compliant llms.txt on WordPress — plugin-free upload, a snippet, or a plugin — plus how to verify it.
WordPress powers a huge share of the web, and adding an llms.txt is quick. The file just has to be served at `https://yoursite.com/llms.txt` as plain text.
## Option 1 — Upload the file (simplest)
Write your file (see [how to create an llms.txt file](/guide/how-to-create-llms-txt)), then upload `llms.txt` to the root web directory (often `public_html/`) via your host's file manager or SFTP. Done — no plugin needed.
## Option 2 — Serve it with a snippet
If you can't write files, add a tiny route. Drop this in your theme's `functions.php` (or a code-snippets plugin):
```
add_action('init', function () {
if (trim($_SERVER['REQUEST_URI'], '/') === 'llms.txt') {
header('Content-Type: text/plain; charset=utf-8');
echo "# My Site\n\n> Short summary.\n\n## Docs\n- [Start](https://mysite.com/start): Get going\n";
exit;
}
});
```
## Option 3 — Use a plugin
Several SEO/AI plugins now generate llms.txt from your pages automatically. Handy, but review the output — auto-generators often include too many links or marketing copy. Keep it curated.
## Watch out for these
- **Caching/CDN:** purge your cache after publishing so the file is served.
- **Right location:** it must be at the domain root, not `/blog/llms.txt`.
- **Plain text:** serve as `text/plain`, not HTML.
## Verify it
Run your domain through the [validator](/) — it confirms the structure and that every linked page actually loads.
---
# llms.txt examples
> Annotated llms.txt patterns — a minimal file, a docs-heavy file, and the llms-full.txt pairing — so you can copy the structure that fits your site.
The fastest way to write a good llms.txt is to start from one that works. Here are three patterns you can adapt.
## 1. The minimal file
Perfect for a small product or landing site. Title, summary, one section of key links.
```
# Acme
> Acme turns CSV files into charts. This file links to the docs an LLM needs to help users.
## Docs
- [Quickstart](https://acme.com/start): Upload a CSV and get a chart in 60 seconds
- [Pricing](https://acme.com/pricing): Plans and limits
```
## 2. The docs-heavy file
For API/SDK sites. Group by purpose, link the Markdown versions of pages, and use an Optional section for secondary material.
```
# Acme API
> REST API for chart generation. Authentication, endpoints, and SDKs below.
## Getting started
- [Authentication](https://acme.com/docs/auth.md): API keys and scopes
- [Quickstart](https://acme.com/docs/quickstart.md): First request in 5 minutes
## Reference
- [Endpoints](https://acme.com/docs/api.md): Every endpoint and parameter
- [Errors](https://acme.com/docs/errors.md): Error codes and handling
## Optional
- [Changelog](https://acme.com/changelog.md): Release history
```
## 3. The llms.txt + llms-full.txt pairing
Big documentation sets often publish both: llms.txt as the index, and [llms-full.txt](/guide/llms-full-txt) with the full content inlined so an agent can ingest everything in one fetch.
## Copy the structure, not the content
Whichever pattern you pick, keep descriptions specific, use absolute HTTPS links, and make sure each one resolves. Then [run it through the validator](/) to confirm it scores 100.
---
# Which AI crawlers read llms.txt?
> A practical rundown of the AI crawlers and answer engines — GPTBot, ClaudeBot, PerplexityBot and more — and how llms.txt and robots.txt control what they see.
llms.txt is a young, voluntary convention, so no crawler is strictly required to read it — but a clean file plus clean pages helps any model that does. It also pairs with the file that actually decides access: [robots.txt](/guide/llms-txt-vs-robots-txt). Think of robots.txt as the gate and llms.txt as the curated map.
## Two kinds of AI crawler
It helps to split AI bots into two groups, because you usually treat them differently:
- **Answer / search crawlers** — fetch pages to answer a user's question right now: `OAI-SearchBot` and `ChatGPT-User` (OpenAI), `Claude-SearchBot` and `Claude-User` (Anthropic), `PerplexityBot` and `Perplexity-User`. These drive AI visibility — you generally *want* them.
- **Training crawlers** — collect data to train models: `GPTBot`, `ClaudeBot`, `Google-Extended`, `Applebot-Extended`, `CCBot`, `Bytespider`, `Meta-ExternalAgent`. Whether to allow these is a separate, opt-out choice.
## Which of them read llms.txt today?
Honestly: adoption is still early. llms.txt is an emerging standard with growing support among AI developer tools and agent frameworks, but most large crawlers do not yet fetch it automatically. The value is in being ready — a correct, curated file costs little and positions you as the standard matures, while the *clean pages* it points to help models right now.
## Access is decided in robots.txt, not llms.txt
llms.txt never blocks or grants anything — it only curates. To control what AI crawlers may fetch, use robots.txt. A visibility-friendly setup allows the answer crawlers and makes a deliberate choice about the training ones:
```
User-agent: OAI-SearchBot
Allow: /
User-agent: PerplexityBot
Allow: /
User-agent: GPTBot
Disallow: /
```
See [llms.txt vs robots.txt](/guide/llms-txt-vs-robots-txt) for how the two files divide the work.
## What to do
- Allow the answer/search crawlers above so AI tools can cite you.
- Decide training opt-outs (`GPTBot`, `Google-Extended`) deliberately — blocking them does not affect AI *search* visibility.
- Publish a curated [llms.txt](/guide/how-to-create-llms-txt), then [validate it](/) so every linked page actually resolves.
---
# Common llms.txt mistakes
> The llms.txt errors we see most — multiple H1s, no summary, broken or relative links, wrong content type, bloated files — and exactly how to fix each one.
Most llms.txt problems fall into a handful of patterns. Here are the ones our [validator](/) flags most often — and the quick fix for each.
## 1. More than one H1
The spec wants exactly one top-level `# Title`. Extra `#` headings confuse the structure. Demote the rest to `##` section headings.
## 2. No blockquote summary
A one- or two-sentence blockquote right under the title is the context a model reads first. Skipping it is the single most common miss. Add one:
```
# Acme
> Acme turns CSV files into charts. These links cover setup, the API, and pricing.
```
## 3. Sections without links (or no sections)
Empty `##` sections add nothing. Each section should hold a Markdown bullet list of links to real pages. If you have no sections at all, group your key pages under headings like `## Docs` and `## Guides`.
## 4. Broken links
A file can be perfectly formatted yet point at dead pages — which wastes a crawler's budget and undermines trust. Every URL must resolve. This is the check most tools skip; we fetch each one.
## 5. Relative or http:// links
Use absolute `https://` URLs everywhere. Models may not resolve relative paths like `/docs/start`, and plain `http://` links look untrustworthy and can break under HTTPS-only crawling.
## 6. The wrong content type
Serve the file as `text/plain; charset=utf-8`. If your server returns `text/html` (a common misconfiguration), some consumers won't treat it as llms.txt.
## 7. A bloated, uncurated file
llms.txt is a curated index, not a sitemap dump. Hundreds of links with no descriptions bury the signal. Keep the best pages, add a short `: description` after each, and move secondary links to an `## Optional` section.
## Catch them all at once
Run your file through the [validator](/) — it scores structure, link reachability, and best practices, and tells you exactly which of the above to fix. New to the format? Start with [how to create an llms.txt file](/guide/how-to-create-llms-txt).
---
# llms.txt for documentation sites
> Docs sites are the ideal llms.txt use case. How to generate one for Docusaurus, MkDocs, Mintlify and others — plus when to add llms-full.txt and Markdown page versions.
Documentation sites are the ideal llms.txt use case: people constantly ask AI tools "how do I do X in *your product*," and a curated file points those models straight at the right pages.
## Why docs benefit most
Your docs already *are* the answers. llms.txt lets you hand a model a clean index of them — getting started, guides, API reference — instead of letting it crawl navigation, search UIs, and marketing pages.
## Generate it from your structure
Most docs sites already have a `sitemap.xml`. Group those URLs into a few sensible sections rather than dumping them flat:
```
# Acme Docs
> Documentation for the Acme API: setup, guides, and the full endpoint reference.
## Getting started
- [Quickstart](https://acme.com/docs/quickstart): First request in 5 minutes
- [Authentication](https://acme.com/docs/auth): API keys and scopes
## Reference
- [Endpoints](https://acme.com/docs/api): Every endpoint and parameter
## Optional
- [Changelog](https://acme.com/docs/changelog): Release history
```
## Link the Markdown versions
Many docs frameworks (Docusaurus, MkDocs, Mintlify, GitBook and others) can serve a Markdown or plain-text version of each page. Link those — `page.md` — so models parse clean content instead of rendered HTML with nav and sidebars.
## Add llms-full.txt for full context
For larger doc sets, publish a companion [llms-full.txt](/guide/llms-full-txt) with the full text inlined, so an agent can ingest everything in one fetch. Keep llms.txt as the concise index.
## Curate, then validate
Whether you hand-write the file or generate it from a plugin, review the output — auto-generators tend to include too much. See [llms.txt examples](/guide/llms-txt-examples) for patterns, then [validate](/) to confirm the structure and that every link resolves.
---
# What is llms.txt?
> llms.txt is a small Markdown file that hands AI models a clean, curated map of your site's most useful pages. Here's what it is, why it exists, and who needs one.
llms.txt is a plain-text file you place at the root of your site — `https://yourdomain.com/llms.txt` — that gives large language models a concise, curated map of your most important content.
## The problem it solves
When an AI assistant answers a question about your product, it has to make sense of pages built for browsers: navigation, menus, cookie banners, ads, and scripts. That's noisy and easy to get wrong. llms.txt cuts through the noise by pointing models straight at the pages that matter, in a format that's trivial to parse.
## What's in the file
It's Markdown, in a fixed order:
- an **H1 title** — your project or site name (the only required element);
- a **blockquote summary** — one or two sentences of context;
- **H2 sections** — grouped lists of links to your key pages, each with a short description.
```
# Acme
> Acme turns CSV files into charts. These links cover setup, the API, and pricing.
## Docs
- [Quickstart](https://acme.com/start): Upload a CSV and get a chart in 60 seconds
- [API reference](https://acme.com/api): Every endpoint and parameter
```
## It is not robots.txt
A common mix-up: llms.txt does not block or allow anything. It only *curates* — access is controlled by [robots.txt](/guide/llms-txt-vs-robots-txt). Think of robots.txt as the gate and llms.txt as the map.
## Who should have one
If people ask AI tools about your docs, API, or product, yes — it's a small file with real upside (see [does llms.txt help SEO?](/guide/does-llms-txt-help-seo)). Documentation sites and developer tools benefit most.
## Next steps
Ready to write one? Follow [how to create an llms.txt file](/guide/how-to-create-llms-txt), then [validate it](/) to confirm the structure and that every link resolves.
---
# Adding llms.txt to Next.js
> Two clean ways to serve a spec-compliant llms.txt from a Next.js app — the public/ folder for a static file, or a route handler for generated content — plus how to verify it.
Next.js makes this easy: the file just has to be served at `https://yoursite.com/llms.txt` as plain text. There are two clean approaches.
## Option 1 — the public/ folder (simplest)
Anything in `public/` is served from the site root. Write your file (see [how to create an llms.txt file](/guide/how-to-create-llms-txt)) and save it as `public/llms.txt`:
```
my-app/
public/
llms.txt # served at https://yoursite.com/llms.txt
app/
package.json
```
No code, no config. Next.js serves it with `Content-Type: text/plain` automatically.
## Option 2 — a route handler (for generated content)
If you'd rather build the file from data (your sitemap, CMS, or MDX), add a route. In the App Router, create `app/llms.txt/route.ts`:
```
export function GET() {
const body = "# My App\n\n> Short summary.\n\n## Docs\n- [Start](https://myapp.com/start): Get going\n";
return new Response(body, {
headers: { "Content-Type": "text/plain; charset=utf-8" },
});
}
```
## Watch out for these
- **Root location:** it must resolve at `/llms.txt`, not `/public/llms.txt` or a subpath.
- **Plain text:** serve as `text/plain`, never HTML.
- **Rewrites:** if you use middleware or rewrites, make sure they don't intercept `/llms.txt`.
## Verify it
Deploy, then run your domain through the [validator](/) — it confirms the structure and that every linked page actually loads.
---
# How to test your llms.txt
> Before you publish, confirm your llms.txt is spec-compliant and every link resolves. Here's what to check — structure, link reachability, best practices — and the fast way to do it.
A file that looks fine can still be malformed or point at dead pages. Here's what to verify before — and after — you publish.
## 1. Structure
Confirm the spec basics: exactly one `#` H1 title, a blockquote summary right below it, and `##` sections that contain Markdown link lists. Multiple H1s or empty sections are the most common structural mistakes (see [common llms.txt mistakes](/guide/common-llms-txt-mistakes)).
## 2. Link reachability
This is the check most tools skip. Every linked URL should actually resolve — a perfectly formatted file that points at 404s wastes a crawler's budget and undermines trust. Request each link and look for broken or redirecting ones.
## 3. Best practices
- Absolute `https://` URLs (not relative or `http://`).
- A short `: description` after each link.
- Served as `Content-Type: text/plain; charset=utf-8`.
## Manual vs automated
You can eyeball the structure and click links by hand, but reachability across dozens of URLs is tedious and easy to get wrong. An automated check does it in seconds and scores the result.
## The fast way
Paste your domain (or the raw text) into the [validator](/). It checks structure, fetches every linked URL concurrently, applies the best-practice rules above, and returns a 0–100 score with a prioritized, fixable list of findings. Re-run it whenever you change the file.
---
# How to make a website agent-ready
> The three layers that make a site usable by AI agents — llms.txt for crawler context, WebMCP for in-browser tools, and A2A for agent-to-agent calls — with the working code we shipped on this validator.
"Agent-ready" means three different things to three different kinds of AI agent — and they stack. Here is exactly how we made this validator agent-ready, with the code we shipped, so you can copy the pattern.
There are three independent layers. Adopt any one on its own; together they cover a crawler reading your site, an agent driving your UI in the browser, and another agent calling you over the network.
## Layer 1 — llms.txt: context for crawlers
The baseline. A plain-text [llms.txt](/guide/what-is-llms-txt) at your root tells an AI crawler what your site is and which pages matter, in priority order. It's read at fetch time — no JavaScript, no protocol. Start here: [how to create one](/guide/how-to-create-llms-txt).
## Layer 2 — WebMCP: tools for in-browser agents
WebMCP lets a page expose callable *tools* to an AI agent running inside the browser, so the agent invokes a typed action instead of guessing at your form. There are two ways, and we ship both.
**Declarative** — annotate a real form and the browser synthesizes a tool from it:
```
```
**Imperative** — register a tool in JavaScript that returns structured data directly:
```
navigator.modelContext?.registerTool({
name: "validate_llms_txt",
description: "Validate a website's llms.txt; returns a 0-100 score and findings.",
inputSchema: { type: "object", properties: { url: { type: "string" } }, required: ["url"] },
execute: (input) => fetch("/api/validate?url=" + encodeURIComponent(input.url))
.then(r => r.json())
.then(data => ({ content: [{ type: "text", text: JSON.stringify(data) }] }))
});
```
Guard the imperative call behind `if (navigator.modelContext)` so it's a no-op where WebMCP is absent. It's a Chrome origin trial today, so real reach is small — treat it as a forward signal, not traffic.
## Layer 3 — A2A: a callable agent for other agents
The Agent2Agent (A2A) protocol lets other agents *discover and call* your service. You publish an agent card and back it with a JSON-RPC endpoint:
```
// GET /.well-known/agent-card.json
{
"name": "llms.txt Validator",
"url": "https://llms-txt-validator.dev/a2a",
"skills": [{ "id": "validate_llms_txt", "name": "Validate llms.txt" }]
}
```
The `url` must point at a working endpoint that speaks A2A — we implement the synchronous `message/send` method, wrapping the same validation logic as a skill. The card is a contract, not a meta tag.
## The one rule: don't publish a signal you can't back
It's tempting to drop an empty agent card or fake form annotations to turn an audit green. Don't. An agent that fetches your card and calls a dead endpoint — or invokes a tool that does nothing — trusts you less afterward. Every signal here should resolve to something real. That's why this [validator](/) reports a WebMCP or A2A signal as "present" only when a working implementation backs it.
## How to verify each layer
- **llms.txt** — paste your domain into the [validator](/); aim for 100/100 with no broken links.
- **WebMCP** — in Chrome 149+, enable `chrome://flags/#enable-webmcp-testing` and run Lighthouse's Agentic Browsing audit; your tools should be listed.
- **A2A** — fetch your `/.well-known/agent-card.json`, then POST a `message/send` call to its `url` and confirm you get a completed task back.
---
# A2A: let AI agents call your site
> A2A (Agent2Agent) is the open protocol that lets one AI agent discover and call another over the network — no browser, no scraping. Here's what it is and how any website can expose a skill, with the working agent we run on this validator.
An AI agent just validated this site without opening a browser, clicking a button, or scraping a page — it read a small JSON file, sent one typed request, and got a structured result back. That exchange is A2A, and any website can offer it.
## What A2A is
A2A (Agent2Agent) is an open protocol — now under the Linux Foundation — that lets AI agents *discover and call each other* over plain HTTP. Think of it as the agent-to-agent counterpart to a public API: instead of a human reading your docs and writing an integration, another agent reads a machine description of what your service does and calls it directly.
It has two parts: a discovery document (the **agent card**) and a callable endpoint (the **skill**).
## 1. The agent card — discovery
You publish a JSON file at `/.well-known/agent-card.json` describing who you are and what you can do. The required fields are `name`, `description`, `version`, `url` (your A2A endpoint) and at least one `skill`:
```
{
"protocolVersion": "0.3.0",
"name": "llms.txt Validator",
"description": "Validate a website's llms.txt and return a score with findings.",
"url": "https://llms-txt-validator.dev/a2a",
"skills": [{ "id": "validate_llms_txt", "name": "Validate llms.txt",
"description": "Given a domain or URL, fetch and validate its llms.txt." }]
}
```
## 2. The endpoint — a callable skill
The card's `url` points at a JSON-RPC 2.0 endpoint. An agent calls the `message/send` method with a message; you do the work and return a `Task`. Here is a real call to our agent:
```
POST /a2a
{ "jsonrpc": "2.0", "id": "1", "method": "message/send",
"params": { "message": { "role": "user",
"parts": [{ "kind": "text", "text": "validate llmstxt.org" }] } } }
```
…and the reply — a completed task carrying a human-readable summary and structured data:
```
{ "result": { "kind": "task", "status": { "state": "completed" },
"artifacts": [{ "parts": [
{ "kind": "text", "text": "Validated llmstxt.org: score 100/100..." },
{ "kind": "data", "data": { "ok": true, "report": { "scores": { "overall": 100 } } } }
] }] } }
```
No browser, no HTML parsing — the agent gets exactly the data it asked for.
## A2A vs WebMCP vs MCP
- **A2A** — networked agents calling your service over HTTP (orchestrators, other agents). This page.
- **WebMCP** — an agent running *inside the browser* calling tools on your open page.
- **MCP** — connecting tools to a single model or app, usually locally.
They're complementary: A2A reaches networked agents, WebMCP reaches in-browser ones. See [how the three fit together](/guide/agent-ready-llms-txt-webmcp-a2a).
## How any site can add one
You don't need the whole protocol to start — pick *one* real thing your service does:
- Serve a valid agent card at `/.well-known/agent-card.json` with one skill.
- Implement the synchronous `message/send` method wrapping that capability, and return a completed `Task` with the result as an artifact.
- Streaming, task history and push notifications are optional — set `capabilities.streaming` to false and add them only when you need them.
## The one rule: back the card with a real endpoint
The card is a contract, not a meta tag. If you publish a card whose `url` doesn't actually answer `message/send`, every agent that trusts it hits a dead end. Expose A2A only for capabilities you can truly serve — that's how we built ours, and it's why our own report marks the signal present only when a working endpoint backs it. Want to see it live? Fetch our [agent card](/.well-known/agent-card.json).
---
# Adding llms.txt to a Shopify store
> Shopify now generates llms.txt natively. Here's how to find it, customize the content with a theme template or app, and keep it useful for AI shopping agents.
As of 2026, Shopify generates an [llms.txt](/guide/what-is-llms-txt) for every store automatically — part of its Agentic Commerce push. Your job is mostly to find it, point it at the right pages, and trim the noise.
## 1. Check what Shopify already serves
Open `https://yourstore.com/llms.txt`. Most stores already return a file. The catch: the default often steers agents toward Shopify's Shop app rather than your own store and docs — so you'll usually want to customize it.
## 2. Customize via a theme template (recommended)
In **Online Store → Themes → ⋯ → Edit code**, open the `Templates` folder and add a new template named `llms.txt.liquid`. Shopify serves this at `/llms.txt`, so its content replaces the default. Write a short, curated file:
```
# Acme Store
> Acme sells handmade goods. This file points AI shopping agents at the pages that matter.
## Catalog
- [Best sellers](https://acme.com/collections/best-sellers): Top products
- [New arrivals](https://acme.com/collections/new): Latest additions
## Help
- [Shipping & returns](https://acme.com/policies/shipping-policy): Policies
- [Contact](https://acme.com/pages/contact): Support
```
## 3. Or use an app
The Shopify App Store has several llms.txt apps that auto-generate the file from your products, collections and pages, and refresh it when the catalog changes. Handy if you don't want to touch theme code — but review the output (see the next step).
## 4. Keep it lean
The most common mistake is dumping every product and blog post in. A 60-line curated file beats a 5,000-line one: agents have limited context, and clutter buries your best pages. List collections and key policies, not the entire catalog.
## 5. Validate
Paste your domain into the [validator](/) to confirm the file is reachable, well-formed, and every link resolves. Re-check after big catalog changes.
---
# Adding llms.txt to a Wix site
> Wix can manage your llms.txt from the SEO settings on supported plans. Here's how to find it, edit it, and what to do if your plan doesn't have it yet.
Wix is rolling out built-in [llms.txt](/guide/what-is-llms-txt) management. On supported plans you edit it from the dashboard; on others there's a fallback. Either way it ends up at `yourdomain.com/llms.txt`.
## 1. Use the built-in tool (supported plans)
In your Wix dashboard, go to **SEO → Tools and settings → Go to LLMs.txt**. Wix auto-generates a file from your site; review and edit the content there. Once published it's served at `/llms.txt` automatically. The feature is rolling out first to Premium / eCommerce plans.
## 2. If you don't see the tool yet
- Upload an `llms.txt` via the Wix file manager; on plans that allow it, place it under `/.well-known/llms.txt`.
- If nothing serves it at the root, contact Wix support and ask them to expose the file at `yourdomain.com/llms.txt` — the rollout is ongoing.
## 3. Velo: a custom route (advanced)
If your site uses Velo (Wix's dev mode), you can serve the file from code with an HTTP function and a redirect, giving you full control over the content. Overkill for most sites, but an option when you need it.
## 4. Curate, then validate
Whatever method you use, keep the file short: a title, a one-line summary, and your most important pages grouped under H2 headings. Then paste your domain into the [validator](/) to confirm it's reachable and every link works.
---
# Adding llms.txt to a Squarespace site
> Squarespace doesn't serve root text files directly, but you can upload your llms.txt and point /llms.txt at it with a URL Mapping. Step by step.
Squarespace won't let you drop a file at the site root, but it does let you upload one and redirect `/llms.txt` to it with a URL Mapping. The result is an [llms.txt](/guide/what-is-llms-txt) crawlers can reach.
## 1. Write and upload the file
Create your `llms.txt` (a title, a one-line summary, your key pages under H2 headings). Upload it through Squarespace's file/asset manager — for example via any page's link editor, which stores it at a CDN path and gives you that URL.
## 2. Redirect /llms.txt to it with a URL Mapping
Go to **Settings → Developer Tools → URL Mappings** and add a line that 301-redirects the root path to your uploaded file:
```
/llms.txt -> /s/llms.txt 301
```
Replace `/s/llms.txt` with the actual asset URL Squarespace gave you, then Save. A crawler requesting `/llms.txt` now follows the redirect to your file.
## 3. Help crawlers find it
Add a link to `/llms.txt` in your footer, and — if you can inject head code — a ``. This makes the file discoverable from your pages.
## 4. Validate
Paste your domain into the [validator](/). It follows the redirect, checks the structure, and confirms every linked URL resolves — so you know agents get a clean file.
---
# Adding llms.txt to a Webflow site
> Webflow can't serve an arbitrary root file by default, but you can host your llms.txt and point /llms.txt at it. Here are the practical options.
Webflow doesn't serve a plain-text file at the site root out of the box, but a couple of practical paths get a real [llms.txt](/guide/what-is-llms-txt) live at `yourdomain.com/llms.txt`.
## Option 1 — Host the file + 301 redirect
Upload your `llms.txt` somewhere it serves as plain text (Webflow's asset manager, or any object storage / CDN). Then in **Site settings → Publishing → 301 redirects**, redirect the root path to it:
```
/llms.txt → https://cdn.example.com/llms.txt
```
A crawler requesting `/llms.txt` follows the redirect to your file. Simple, with no extra infrastructure if you already have somewhere to host the text.
## Option 2 — A reverse proxy / edge (most robust)
If your Webflow site sits behind Cloudflare (or similar), serve `/llms.txt` directly from a small edge worker that returns your text with `Content-Type: text/plain`. This keeps the canonical root URL with no redirect hop — the cleanest result.
## Make it discoverable
Either way, add a footer link to `/llms.txt` and, via custom code in the page ``, a `` so crawlers find it from your pages.
## Curate and validate
Keep the file short — a title, a one-line summary, and your most important pages under H2 headings, with absolute HTTPS links. Then paste your domain into the [validator](/) to confirm it's reachable and every link resolves.
---
# Adding llms.txt to a Ghost site
> Ghost doesn't drop a root file for you, but serving it from your web server, or redirecting to a hosted file, gets a working llms.txt live. Step by step.
Ghost serves posts and pages, not arbitrary root files — but a couple of routes get a real [llms.txt](/guide/what-is-llms-txt) live at `yourdomain.com/llms.txt`.
## Self-hosted: serve it from your web server (best)
If you run Ghost behind Nginx, Caddy or a CDN, serve `/llms.txt` there — before Ghost. In Nginx:
```
location = /llms.txt {
default_type text/plain;
alias /var/www/llms.txt;
}
```
This returns your file directly as plain text, with no redirect — the cleanest result.
## Ghost(Pro) or no server access: redirect to a hosted file
Host the raw text somewhere it serves as `text/plain` (object storage, a CDN, a raw file host). Then add a redirect from `/llms.txt` to it — either in Ghost's `redirects.yaml` (**Settings → Labs → Redirects**) or at your CDN. A crawler follows the 301 to your file.
## Keep it discoverable and lean
Add a footer link to `/llms.txt`, keep the file short (title, one-line summary, key pages under H2 headings), and use absolute HTTPS links.
## Validate
Paste your domain into the [validator](/) to confirm it's reachable as plain text and every link resolves.
---
# Adding llms.txt to a Framer site
> Framer added native static files in 2026 — upload your llms.txt from the Files tab under Domains, publish, and it's live at the root. Here's the full flow.
Since its 2026 Static Files release, Framer serves custom files at the root — so an [llms.txt](/guide/what-is-llms-txt) is a direct upload, with no redirects or workarounds.
## 1. Open the Files tab
In your Framer workspace, go to **Domains → Files** (the Static Files area). This is where Framer hosts root and well-known files for your custom domain.
## 2. Upload your llms.txt
Write a short, curated file — a title, a one-line summary, and your key pages under H2 headings with absolute HTTPS links — and upload it. It is served at `yourdomain.com/llms.txt`. Static / well-known file hosting requires a paid plan (Pro, Scale or Enterprise).
## 3. Publish
Uploaded files don't go live until you publish the site. After publishing, open `yourdomain.com/llms.txt` in a browser to confirm it serves.
## 4. Validate
Paste your domain into the [validator](/) — it confirms the file is reachable as plain text, well-formed, and that every linked URL resolves.
---
# Adding llms.txt to a Drupal site
> Drupal has modules that generate /llms.txt from your content, or you can drop a static file in the docroot since you control the server. Both covered.
Drupal gives you two clean paths to an [llms.txt](/guide/what-is-llms-txt): a contributed module that generates it from your content, or a static file in the docroot since you control the server.
## Option 1 — a contributed module (auto-generated)
Modules in the Drupal ecosystem expose a `/llms.txt` endpoint built from your published content — for example a plain-text summary organized by content type. Install with Composer and enable it:
```
composer require drupal/llms_txt
drush en llms_txt
```
Then configure which content types and fields feed the file. Good for large or frequently-changing sites.
## Option 2 — a static file in the docroot
Because Drupal is self-hosted, you can place a hand-written `llms.txt` in your site's web root, next to `index.php` (e.g. `web/llms.txt` or `docroot/llms.txt`). Drupal's `.htaccess` serves existing static files directly, so it's available at `/llms.txt` immediately. Best when you want full control over the content.
## Keep it curated
Whichever route you choose, link your highest-value pages, not every node. A short, focused file beats an exhaustive dump.
## Validate
Paste your domain into the [validator](/) to confirm the file is reachable and every link resolves.
---
# Adding llms.txt to a Joomla site
> Joomla is self-hosted, so the simplest reliable way to add llms.txt is to drop the file in your site's web root. Step by step.
Joomla runs on your own hosting, so you don't need an extension — the most reliable way to publish an [llms.txt](/guide/what-is-llms-txt) is to put the file in your site's web root.
## 1. Write the file
Create `llms.txt` with a title, a one-line summary, and your key pages grouped under H2 headings, using absolute HTTPS links. Keep it short and curated.
## 2. Upload it to the web root
Place `llms.txt` in the same directory as Joomla's `index.php` — your public web root (often `public_html/`) — via your host's file manager or SFTP. Joomla's `.htaccess` serves existing files directly, so it's live at `/llms.txt` right away.
## 3. Help crawlers find it
Add a footer link to `/llms.txt`, and if your template allows head code, a ``.
## 4. Validate
Paste your domain into the [validator](/) to confirm it's reachable as plain text and every linked URL resolves.
---
# Adding llms.txt to a static site generator
> Static generators copy a static/public folder straight to your site root. Here's exactly where llms.txt goes in Hugo, Jekyll, Astro and Eleventy.
Static site generators have a folder whose contents are copied verbatim to your published site root — so adding an [llms.txt](/guide/what-is-llms-txt) is just dropping the file in the right place and rebuilding.
## Where the file goes, per generator
- **Astro** — `public/llms.txt` (everything in `public/` is served from the root).
- **Hugo** — `static/llms.txt` (the `static/` directory is copied to the output root). A custom output format also works for generating it.
- **Eleventy (11ty)** — add a passthrough copy, e.g. `eleventyConfig.addPassthroughCopy("llms.txt")`, so the file lands in the output.
- **Jekyll** — put `llms.txt` in the project root; Jekyll copies static files through to `_site` as-is.
## Build and verify
Run your build (`astro build`, `hugo`, `npx @11ty/eleventy`, `jekyll build`) and confirm `llms.txt` appears at the root of the output directory, then deploy.
## Generate it from your content (optional)
For docs-style sites, plugins exist (for Astro Starlight, Docusaurus, MkDocs, VitePress and others) that build the file from your pages automatically. Handy when content changes often — but keep the output curated.
## Validate
Paste your domain into the [validator](/) to confirm the file is reachable as plain text and every linked URL resolves.
---
# Adding llms.txt to Magento (Adobe Commerce)
> Magento can generate llms.txt with an extension, or you can serve a static file from the web root. Both methods, step by step.
Magento (Adobe Commerce) reaches an [llms.txt](/guide/what-is-llms-txt) two ways: an extension that generates it from your catalog, or a static file you control in the web root.
## Option 1 — an LLMs.txt extension (auto-generated)
Marketplace extensions generate `/llms.txt` from your store data. They typically let you choose which entities feed the file (products, categories, CMS pages) and how often it regenerates — compatible with current Magento 2.4.x. Best for large catalogs that change often.
## Option 2 — a static file in the web root
On self-hosted Magento you control the server, so place a hand-written `llms.txt` in the public web root (the `pub/` directory, alongside `index.php`). It's served at `/llms.txt` directly — best when you want to curate the content by hand.
## Keep it lean
Don't dump the whole catalog. Link your top categories, best sellers and key policy pages under H2 headings, with absolute HTTPS links — a short file is easier for an agent to use.
## Validate
Paste your domain into the [validator](/) to confirm the file is reachable and every link resolves. Re-check after big catalog changes.
---
# Adding llms.txt to HubSpot CMS
> HubSpot has no native llms.txt yet, but the File Manager plus a URL redirect get one live at your root. Step by step.
HubSpot CMS doesn't serve a root text file natively (it's an open feature request), but its File Manager and URL Redirects combine to put a real [llms.txt](/guide/what-is-llms-txt) at `yourdomain.com/llms.txt`.
## 1. Upload the file to the File Manager
Write your `llms.txt` (a title, a one-line summary, key pages under H2 headings, absolute HTTPS links). In HubSpot, open the **File Manager** (Marketing → Files) and upload it. HubSpot stores it on its CDN and gives you a file URL.
## 2. Redirect /llms.txt to it
Go to **Settings → Content → URL Redirects** and add a redirect from `/llms.txt` to the File Manager URL. A crawler requesting `/llms.txt` follows it to your file.
## 3. Help crawlers find it
Add a footer link to `/llms.txt`, and in your site header HTML a ``.
## 4. Validate
Paste your domain into the [validator](/). It follows the redirect, checks the structure, and confirms every linked URL resolves.
---
# Adding llms.txt to a Bubble app
> Bubble can't serve a plain-text root file by itself, but an edge proxy or a hosted file with a redirect get a working llms.txt live. Here's how.
Bubble renders your app as HTML and doesn't serve arbitrary plain-text files at the root — so an [llms.txt](/guide/what-is-llms-txt) needs a small layer in front. Two reliable options.
## Option 1 — an edge proxy (most robust)
If your Bubble app is behind Cloudflare (or another CDN) on your custom domain, serve `/llms.txt` directly from a small edge worker that returns your text with `Content-Type: text/plain`. This keeps the canonical root URL and never touches Bubble.
## Option 2 — host the file + redirect
Host the raw text where it serves as plain text (object storage or a CDN), then redirect `/llms.txt` to it at your DNS/CDN layer. A crawler follows the redirect to your file.
## Why not a Bubble page?
A Bubble page named "llms.txt" still renders as the HTML app, not plain text, so it won't validate. The file must be served as `text/plain` — hence the proxy or hosted-file approach.
## Validate
Paste your domain into the [validator](/) to confirm `/llms.txt` is reachable as plain text and every link resolves.
---
# Adding llms.txt to a Notion site
> Notion's native publishing can't serve a root text file, but an edge proxy or a Notion-site platform gets a working llms.txt live. Your options.
Notion's built-in site publishing is locked down — it serves your pages, not custom files — so an [llms.txt](/guide/what-is-llms-txt) needs help from the layer around it.
## Option 1 — an edge proxy on your custom domain
If you serve your Notion site through Cloudflare (or a similar CDN) on a custom domain, serve `/llms.txt` from a small edge worker that returns your text as `Content-Type: text/plain`. This is the most reliable route and keeps the canonical root URL.
## Option 2 — a Notion-site platform that supports it
Tools that publish Notion content as a site (Super, Potion, Notiondesk and others) add capabilities Notion lacks — custom code, redirects, and in some cases an auto-generated `llms.txt` built from your pages. If you use one, check its docs or AEO settings.
## Native Notion alone?
On a plain notion.site with no proxy or builder, there's no supported way to serve a plain-text root file — so use one of the options above.
## Validate
Paste your domain into the [validator](/) to confirm `/llms.txt` is reachable as plain text and every link resolves.
---
# Adding llms.txt to a Carrd site
> Carrd can't serve a root text file on its own — here's the honest, working way to get an llms.txt live for a Carrd site.
Carrd builds lightweight one-page sites and doesn't serve arbitrary files or redirects — so a true [llms.txt](/guide/what-is-llms-txt) at the root needs a thin layer in front. Here's the honest path.
## Use an edge proxy on your custom domain
Point your custom domain through Cloudflare (or a similar CDN) and serve `/llms.txt` from a small edge worker that returns your text as `Content-Type: text/plain`. The worker answers `/llms.txt` before the request reaches Carrd — the only reliable way to get a real root file on a Carrd site.
## At minimum: point to a hosted file
If you can't run a proxy, host the raw `llms.txt` elsewhere (object storage or a CDN) and, on a Carrd Pro plan, add a `` to it via the embed / custom-code element. It's not the canonical root path, but it advertises the file.
## Keep it tiny
A Carrd site is small, so its llms.txt should be too: a title, a one-line summary, and a handful of key links.
## Validate
Paste your domain (or the file's URL) into the [validator](/) to confirm it's reachable as plain text and every link resolves.