llms.txt and schema markup do different jobs, so llms.txt complements schema markup and does not replace it. Keep your schema on the pages where it describes visible content, and add an llms.txt file only when a curated list of your key pages would help.

Four pieces sit close together on most sites: schema markup, robots.txt, an XML sitemap and llms.txt. Each has its own reader and its own limit. Decide which one you are changing before you edit anything.

The checks are the same whether you run WordPress, Shopify, Wix, Squarespace, Webflow or a hand-built site. Look at what the live page actually serves, then test it with the tool that matches the engine you care about.

Key takeaways

  1. Complement, do not replacellms.txt complements schema markup and does not replace it. Add llms.txt only if a curated list of your key pages would help.
  2. Give each piece its jobSchema markup describes entities, robots.txt states crawler access, an XML sitemap lists canonical URLs and llms.txt gives a curated list of links. None stands in for another.
  3. Google's llms.txt statementGoogle says its Search and generative AI features do not use llms.txt (June 2026). That is a statement about Google, not a reason to remove schema markup.
  4. Set up in orderPublish accurate visible content first, then add matching JSON-LD, open robots.txt to the crawlers you want, keep a sitemap, and add llms.txt last if it helps.
  5. Allow the crawlers you wantOpenAI recommends allowing OAI-SearchBot if you want ChatGPT Search to surface your pages, and says placement is not guaranteed. Other providers document their own crawlers.
  6. Keep every piece in stepOpen the live page and /llms.txt, then confirm the JSON-LD matches visible text and every link resolves. Update visible content, JSON-LD, sitemap and llms.txt together.

What llms.txt does

llms.txt is a proposed Markdown file served at /llms.txt. Jeremy Howard published the proposal on September 3, 2024 (llmstxt.org). It is an open community convention, not a W3C or IETF standard. Its purpose is to give AI agents a short overview of a site, with links to the pages that matter most.

The format is plain. An H1 holds the site or project name, and a blockquote holds a short summary. Optional prose can add context, and optional H2 sections hold lists of links written as [name](URL), each with a short description. A section titled Optional can hold secondary material.

The file can sit at the root of the site or under a path such as /docs/llms.txt. A file under a path covers the URLs beneath that path, and a more specific file takes precedence when several apply. The proposal also suggests clean Markdown versions of important pages, such as /guide.md, and optional rel="alternate" and rel="describedby" links.

llms.txt controls no access and describes no entities. It is a curated guide for systems that choose to read it. The proposal is written to coexist with robots.txt, sitemaps and structured data: a sitemap lists the whole inventory of a site, while llms.txt is a smaller, selected overview.

What schema markup does

Schema markup is machine-readable data embedded in a page that says what the page and the things on it are. Schema.org supplies the vocabulary, such as BlogPosting, Organization and BreadcrumbList. JSON-LD is the most common way to write it, and JSON-LD 1.1 is a W3C Recommendation published July 16, 2020 (W3C JSON-LD 1.1).

Each described thing is an entity: an article, an organization, a product, an event, a breadcrumb trail.

A woman in a mustard cardigan stands at a desk in a bright home office, holding a pen beside a monitor with blurred abstract blocks on screen
Figure 1. Schema markup describes the page's entities, and it should match what a reader sees on the page.

Schema markup should match what visitors can see on the page. Google's general guidelines require structured data to describe visible content accurately, so fabricated ratings, reviews or facts do not belong in it (Google general structured data guidelines).

Google says structured data helps its systems understand page content and can make a page eligible for supported search features, and it adds that appearance is not guaranteed (Google structured data gallery). Schema.org validity and Google feature eligibility are separate questions: a type can be valid vocabulary without any Google feature behind it.

FAQPage is one example. It remains valid schema.org vocabulary (Schema.org FAQPage), but Google stopped showing FAQ rich results in May 2026, as covered in the news post on Google retiring FAQ rich results. Mark up FAQ content only when it is visible on the page, and do not expect a Google rich result from it.

How the four pieces fit together

Each piece answers a different question and reaches a different reader, with a limit of its own.

  • Schema markup describes entities and their relationships on one page. Its readers include search engines, crawlers, knowledge systems, validators and AI systems that parse it. It uses JSON-LD, Microdata or RDFa, and it grants or denies no access.
  • robots.txt states which crawlers may fetch which paths. Search crawlers and vendor bots read it. It holds User-agent rules, Allow and Disallow lines and sitemap locations, and it is the only one of the four that works as an access directive (Google robots.txt introduction).
  • XML sitemap lists canonical URLs, with optional lastmod and optional image, video or news data. Search engines and crawlers read it to locate pages (Google sitemap overview). It describes no page content.
  • llms.txt gives a curated Markdown summary and a short list of links to AI agents, coding agents and retrieval systems that choose to support it. It grants no access and carries no entity data.
An illustration of a tall stack of page tiles and a short sheet of highlighted links, both connected to one central page card
Figure 2. A sitemap lists the whole inventory, while llms.txt is a short curated index.

Because the roles differ, one piece cannot stand in for another. A sitemap will not tell a system what an Organization is, and schema will not stop a crawler from fetching a blocked path. An llms.txt file can point to your best pages, but access rules live in robots.txt.

For most sites the working order is visible content, then schema where it fits, then crawl controls, then a sitemap, and llms.txt last and only when a curated index would help. The guide on what to add first for AI search covers which schema types come first.

Keep Bing and AI search crawlers able to read your pages

Google says Google Search and its generative AI features do not use llms.txt (clarification added June 15, 2026, Google AI search guidance). That is no reason to remove schema markup, which Google documents separately for eligible search features; the news post on Google's llms.txt clarification gives the detail. Bing reads Schema.org in JSON-LD, Microdata and RDFa, so one JSON-LD block serves both engines (Bing structured data).

To let AI search crawlers reach your pages, allow OAI-SearchBot in robots.txt, as OpenAI recommends (OpenAI crawler documentation). Perplexity documents PerplexityBot (Perplexity crawler documentation), and Anthropic says ClaudeBot honors robots.txt (Anthropic crawler documentation). For how AI systems use markup, see whether AI systems use schema markup.

Write a minimal llms.txt

Start with the pages a reader or an agent would need to understand the business: an about page, the main service or documentation pages, a process page and a contact page. Put policies such as terms and privacy under the Optional heading. The example below uses a fictional studio on example.com.

text
# Bright Example Studio

> Bright Example Studio creates fictional brand identity and website design resources for small businesses.

The site publishes practical guides, service details, and contact information. The pages below are the primary references for understanding the business.

## Important pages

- [About Bright Example Studio](https://example.com/about): Company background and editorial information.
- [Website design services](https://example.com/services/website-design): Description of the service and deliverables.
- [Project process](https://example.com/process): Typical project stages and responsibilities.
- [Contact](https://example.com/contact): Contact methods and business inquiries.

## Optional

- [Terms](https://example.com/terms): Website terms and conditions.
- [Privacy](https://example.com/privacy): Privacy policy.

Replace the studio name, the summary and every URL with your own, and list only pages that exist and are current. Leave out private pages, outdated claims and anything you would not want repeated as a description of your business. The H1 is the one required part; the blockquote and link sections follow the proposal's structure.

To build the file without writing it by hand, the Schema Nova llms.txt generator produces the Markdown from your pages. Then add the file through your platform's documented static-file, theme, CMS or deployment workflow, whether that is WordPress, Shopify, Wix, Squarespace, Webflow or a hand-built site. Whatever the route, open /llms.txt in a browser afterward and confirm it returns the text you intended.

Add JSON-LD for an article

The JSON-LD below describes a blog article, the organization that publishes it and, in a second block, the breadcrumb trail. It uses fictional names and example.com URLs. Replace each URL, the headline, the description, the image, the dates and the organization details with values that match your own page, and keep the dates in the same format.

The article points to the Organization by @id, so the publisher is described once and referenced twice. An @id is a stable identifier for an entity; the guide to entity SEO with sameAs and @id explains how to keep them consistent across pages.

json
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "BlogPosting",
      "@id": "https://example.com/blog/llms-txt-vs-schema-markup/#article",
      "isPartOf": { "@id": "https://example.com/blog/llms-txt-vs-schema-markup/" },
      "mainEntityOfPage": { "@id": "https://example.com/blog/llms-txt-vs-schema-markup/" },
      "headline": "llms.txt vs Schema Markup: What Each One Does",
      "description": "A practical guide to llms.txt, schema markup, robots.txt, and XML sitemaps.",
      "image": ["https://example.com/images/llms-txt-schema-markup-16x9.jpg"],
      "datePublished": "2026-07-14T09:00:00-06:00",
      "dateModified": "2026-07-14T09:00:00-06:00",
      "author": { "@id": "https://example.com/#organization" },
      "publisher": { "@id": "https://example.com/#organization" },
      "articleSection": "Schema for AI search",
      "inLanguage": "en-US"
    },
    {
      "@type": "Organization",
      "@id": "https://example.com/#organization",
      "name": "Bright Example Studio",
      "url": "https://example.com/",
      "logo": "https://example.com/images/bright-example-logo.png",
      "description": "Bright Example Studio is a fictional web design publisher.",
      "sameAs": ["https://social.example.org/bright-example-studio"]
    }
  ]
}

Put this inside a script element with type="application/ld+json", either in the page head or in the body. If your theme or SEO plugin already outputs an Article, update that output instead of adding a second description of the same article.

Google says Article structured data has no required properties and recommends adding the applicable ones, such as headline, image, datePublished, dateModified and author (Google Article structured data). It says the same about Organization, where name, url, logo and sameAs are among the recommended properties (Google Organization structured data). To generate the article block from your own details, use the Article schema generator.

BreadcrumbList works differently. Google lists itemListElement as required for its breadcrumb feature, with at least two ListItem entries, each carrying position, name and item. The item can be left off the final crumb, where Google can use the containing page URL (Google breadcrumb structured data). Add this block as its own script element, or move its object into the @graph above.

json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "@id": "https://example.com/blog/llms-txt-vs-schema-markup/#breadcrumb",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://example.com/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://example.com/blog/"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "llms.txt vs Schema Markup",
      "item": "https://example.com/blog/llms-txt-vs-schema-markup/"
    }
  ]
}

Change the names and URLs to match the trail visitors see on your page. These labels describe Google's feature documentation, so they do not cover every consumer, and Schema.org vocabulary stays valid whether or not a Google feature uses a property.

Set up the pieces in order

Begin with the page itself. Publish accurate visible content first, because schema, llms.txt and sitemap entries all describe or point to it. Then add the JSON-LD that fits each page type, and keep it limited to what the page shows.

Next, open robots.txt to the crawlers you want to serve. If you want ChatGPT Search to be able to surface your pages, OpenAI recommends allowing OAI-SearchBot. Decide separately about GPTBot, PerplexityBot, ClaudeBot and any others, since each provider describes its own crawlers. Keep an XML sitemap that lists canonical URLs only, and point to it from robots.txt.

Only then decide about llms.txt. Add it when you have documentation, policies, service information or other pages that a curated index would help a person or an agent reach. If you do not, the other three pieces still stand on their own. When you do publish it, link to the same canonical URLs your sitemap lists.

Finish by testing and by planning maintenance. Every time a page, a price, a service or a URL changes, update the visible content, the JSON-LD, the sitemap and the llms.txt entry together, so no piece describes something the others have dropped.

Set up the four pieces in order

This order keeps each piece consistent and testable. It does not guarantee rankings, rich results, AI citations or traffic.

  1. Visible contentPublish accurate content on the page first.
  2. JSON-LDAdd schema that matches what the page shows.
  3. robots.txt and sitemapOpen crawl access for the bots you serve and list canonical URLs.
  4. llms.txtOptionally publish a concise summary and curated links.
  5. ValidateTest with the tool for each engine and feature you target.
  6. Inspect and updateWatch crawl access and displays, then update every piece together.

Test the rendered page

Test the page a visitor and a crawler receive, not the template you edited. Open the live URL and look at the raw HTML to confirm the JSON-LD is present and that the values match the visible text.

Google's Rich Results Test checks a page against the requirements of a specific Google feature. Use it when you are aiming at a feature that still exists, and remember that a pass does not guarantee a rich result. The Schema Markup Validator at schema.org checks vocabulary only, so it will accept a valid type that no Google feature supports. URL Inspection in Search Console is Google's tool for inspecting one specific URL.

For Bing, Bing Webmaster Tools offers URL Inspection with a Markup card that shows the JSON-LD it read (Bing URL Inspection). For Yandex, the Yandex Webmaster structured data validator supports its listed formats (Yandex structured data validator). For Apple, use the validation tool in the Apple web markup guide. Schema Nova's schema validator and schema checker are free tools for checking code or a URL.

For llms.txt, load /llms.txt in a browser and confirm that every link resolves. For ChatGPT Search, Perplexity and Claude, test robots.txt rules, watch your crawl logs and inspect the HTML each page returns.

Keep every version in step

None of the four pieces guarantees a ranking, a rich result, an AI citation or traffic, and a passing test does not either. They make a site easier to crawl, describe and test, which is a technical benefit with its own limits. Provider support changes, so re-read the documentation for the engines you rely on from time to time.

Keep the pieces consistent with each other. An llms.txt link to a page that has moved, a sitemap that lists a redirected URL, or schema that states a price the page no longer shows each gives a system two different answers. Keep canonical URLs consistent across the HTML, the schema, the sitemap and llms.txt.

If you work with answer engines, the guide on schema for AEO and GEO explains those terms and how they relate to the markup here. For the two files you can generate with Schema Nova tools, the llms.txt generator builds the Markdown and the Article schema generator builds the JSON-LD.

Questions people ask

Does llms.txt replace schema markup?

No. llms.txt gives a curated Markdown overview with links, while schema markup describes the entities on each page in a form parsers and validators can read. Publishing one does not remove the need for the other.

Do I need both llms.txt and schema markup?

Schema markup fits any page where it can describe visible content. llms.txt is optional, and it makes most sense for sites with documentation, policies, service information or other key pages worth listing. A site can publish schema without llms.txt, and an llms.txt file does not require changes to existing schema.

Does Google use llms.txt?

Google says Google Search and its generative AI features do not use llms.txt (clarification added June 15, 2026). That is a statement about Google Search, so it does not decide what other providers do, and it is no reason to remove schema markup.

Does llms.txt replace robots.txt or an XML sitemap?

No. robots.txt states which crawlers may fetch which paths, and an XML sitemap lists the canonical URLs you want crawled. llms.txt is a smaller curated guide and controls no access.

What should a small business put in llms.txt?

A short summary of the business and links to the pages that explain it: about, main services, process, contact, and any policies under the Optional heading. Include only current, public pages, and write plain descriptions that match what each page says.

Does schema markup guarantee rich results or AI citations?

No. Google says structured data can make a page eligible for supported search features but does not guarantee appearance, and Bing says annotations do not guarantee a rich result. Schema markup does not guarantee AI citations or traffic either.

Quick check: which piece does what?

Choose an answer to see feedback. Nothing is scored or saved.

Question 1 of 3

Which file primarily controls whether a crawler may access a path?

Question 2 of 3

Which item primarily describes what a page or entity is?

Question 3 of 3

Which item is a curated Markdown guide with links, for agents that support the convention?

Glossary

Select a term to see its definition.

llms.txt. A proposed Markdown overview and link index for AI agents, served at /llms.txt.