llms.txt
# ReadMe
> ReadMe helps teams build beautiful, interactive, personalized API documentation that developers (and AI agents) love.
Every page on this site is also available as Markdown: request it with an `Accept: text/markdown` header or append `.md` to the URL.
## Pages
- [ReadMe](https://readme.com/): Interactive API documentation that helps developers succeed with your API.
- [About ReadMe](https://readme.com/about): The team and story behind ReadMe.
- [ReadMe for AI](https://readme.com/ai): Make your API and docs work seamlessly with AI agents and LLMs.
- [AI-Ready Documentation](https://readme.com/ai-ready-documentation): Documentation built to be consumed by AI agents and LLMs.
- [API Documentation Template](https://readme.com/api-documentation): A template for great API documentation.
- [ReadMe Blog](https://readme.com/blog): Product news, guides, and field notes on API documentation, developer experience, and docs for AI from the ReadMe team.
- [Customers](https://readme.com/customers): How teams use ReadMe to build better developer experiences.
- [Book a Demo](https://readme.com/demo): See ReadMe in action with a personalized walkthrough.
- [API Documentation](https://readme.com/documentation): Beautiful, interactive documentation for your API.
- [ReadMe Enterprise](https://readme.com/enterprise): Security, scale, and support for large teams.
- [Help Center Template](https://readme.com/help-center): A template for a customer help center.
- [ReadMe vs. Postman](https://readme.com/postman): How ReadMe compares to Postman for API documentation.
- [Pricing](https://readme.com/pricing): Plans and pricing for teams of every size.
- [Privacy Policy](https://readme.com/privacy): How ReadMe handles your data.
- [Resources](https://readme.com/resources): Guides and best practices for API docs, developer experience, and AI.
- [Professional Services](https://readme.com/services): Expert help migrating to and getting the most out of ReadMe.
- [ReadMe for Startups](https://readme.com/startup): ReadMe pricing and perks for early-stage startups.
- [Technical Documentation Template](https://readme.com/technical-documentation): A template for technical product documentation.
- [Terms of Service](https://readme.com/tos): ReadMe's terms of service.
- [Our Values](https://readme.com/values): What we care about at ReadMe.
## Blog
- [Stripe's Docs Aren't Written. They're Generated, and Then Served Three Ways.](https://readme.com/blog/stripe-developer-portal-teardown)
- [Introducing Restless, the Modern API Toolkit](https://readme.com/blog/restless): Documentation is for reading. Restless is for building.
- [The best Mintlify alternatives in 2026, and what each one asks you to hand over](https://readme.com/blog/mintlify-alternatives): For API teams weighing Mintlify alternatives, this compares seven platforms on live pricing and AI review workflow, checked September 2026.
- [What is API Documentation (And How to Write it Well)](https://readme.com/blog/what-is-api-documentation): What API documentation is, the five types your API needs, and a seven-step process for writing docs developers can build with.
- [MCP Metrics: See how agents use your API and docs](https://readme.com/blog/mcp-metrics): See which clients and tools drive traffic to your MCP server, inspect the requests behind each call, and investigate errors and slow responses.
- [Is ReadMe worth it in 2026? Six objections, answered](https://readme.com/blog/is-readme-worth-it): If you looked at ReadMe before mid-2025, here's what's changed, and the one tradeoff we'd still make.
- [ReadMe vs Fern: How Teams Choose Between an SDK Pipeline and a Docs Hub](https://readme.com/blog/readme-vs-fern): Fern generates SDKs. ReadMe shows you what developers do after they read the page. A live-checked comparison of free tiers, what's behind each sales call, and the tradeoffs each product actually chose.
- [Introducing Ask AI V2 and a New Search Experience](https://readme.com/blog/ask-ai-v2): Bring pages and answers together in search. Ask AI V2 answers your users’ questions with sources from your docs.
- [ReadMe vs. GitBook: Which is the Best API Documentation Tool in 2026?](https://readme.com/blog/readme-vs-gitbook): GitBook shows what happened in your docs. ReadMe connects that to what happened in your API. Here's how the two compare on API testing, design control, AI discoverability, and pricing in 2026.
- [ReadMe vs Mintlify: How Teams Choose an API Documentation Platform in 2026](https://readme.com/blog/readme-vs-mintlify): How ReadMe and Mintlify actually compare in 2026: who can edit docs without a pull request, what happens after an API request runs, and what AI costs on each plan.
- [AGENTS.md for AI Coding Assistants: Best Practices for API Docs](https://readme.com/blog/agents-md): Learn how to write AGENTS.md files that guide AI coding assistants, cut hallucinated endpoints, reduce token usage, and keep your API docs in sync.
- [What Is CLAUDE.md? A Guide for API Documentation Teams](https://readme.com/blog/what-is-claude-md): Learn what a CLAUDE.md file is, why API documentation teams should use one, and how to create, maintain, and use it with AI-ready developer documentation.
- [What is an MCP Server? How to Connect One to Your Docs](https://readme.com/blog/what-is-an-mcp-server): An MCP server lets an AI agent discover, read, and call your API directly. Here's how MCP works and how to connect one to your docs with ReadMe.
- [Just Enough AI, Part 1: AI for Search and Discoverability](https://readme.com/blog/just-enough-ai-part-1): This is the first in a three-part series on ways technical writers can use AI as an assistant, not as a boss. This post is about using AI to help users and LLMs find things in your documentation.
- [5 Great Technical Documentation Examples (And What You Can Learn From Them)](https://readme.com/blog/technical-documentation-examples): These technical API documentation examples are detailed, well-organized, and interactive, helping you spend less time handling support requests.
- [API Versioning: 7 Best Practices to Keep Your Docs Accurate Across Every Version](https://readme.com/blog/api-versioning-best-practices): Learn seven API versioning best practices to prevent breaking changes, reduce documentation debt, and keep every version of your developer docs in sync with your code.
- [Best Practices for API Documentation: How to Write, Maintain, and Scale Your Docs](https://readme.com/blog/best-practices-for-creating-api-documentation): Learn the API documentation best practices that help developer teams write clearer reference content, keep docs in sync with their codebase, and scale quality as their API grows.
- [Committing to Git](https://readme.com/blog/committing-to-git): History, branching, and merging kept compounding complexity on top of Mongo. Now every save is a real Git commit, with true two-way sync to GitHub, GitLab, and Bitbucket.
- [How to Structure and Optimize Your Documentation for AI Visibility](https://readme.com/blog/ai-visibility-api-docs): AI visibility helps AI tools surface accurate API guidance from your docs. Find out how to structure pages, add context, and maintain AI-ready documentation.
- [Announcing Shareable Branches](https://readme.com/blog/shareable-branches): Every branch now has a shareable URL, so you can get feedback from anyone on your team — no ReadMe login required.
- [Redesigned Audit Logs](https://readme.com/blog/audit-logs): Updated search features, persistent URLs, and CSV export make it easier than ever to keep track of changes across every project in your Enterprise organization.
- [Keep Your Docs Consistent With the AI Linter](https://readme.com/blog/linter-style-guide): How to use ReadMe's AI Linter as a style guide enforcer, with tips for writing rules and prompts that actually work.
- [How to Get Your API Documentation LLM-Ready (+ Checklist)](https://readme.com/blog/llm-ready-api-documentation): A practical breakdown of what LLM-ready API documentation looks like, plus a checklist to audit your current setup.
- [Migrating Enterprise Documentation to ReadMe](https://readme.com/blog/enterprise-documentation-migration): Enterprise docs migrations fail on structure, not content transfer. Learn how to approach your migration strategically and get your docs into ReadMe the right way.
- [Reviews and Notifications for Enterprise Branching](https://readme.com/blog/branching-reviews): Branching gave your team a way to edit docs without pushing straight to production. Now reviews and notifications complete the workflow, so you know what's changed, who reviewed it, and when it went live.
- [Introducing GitHub AI Writer](https://readme.com/blog/ai-writer): ReadMe's AI Writer watches your codebase, detects changes that affect your docs, and creates a branch with proposed updates. Now, you can stop chasing code changes and start reviewing drafts.
- [The ReadMe CLI Tool](https://readme.com/blog/cli): We rebuilt our CLI tool from the ground up. It's great for writing docs without leaving your terminal, for both humans and AI.
- [A New ReadMe, Built to Work with AI](https://readme.com/blog/may-launch): We're rolling out a new ReadMe, redesigned for writers looking to work more effectively with AI to create documentation that helps developers build with agents.
- [Introducing MDX-ish](https://readme.com/blog/mdxish): We built a new rendering engine for ReadMe, which combines the permissiveness of Markdown with the power of MDX!
- [Give AI Agents Direct Access to Your API with ReadMe's MCP Server](https://readme.com/blog/api-documentation-mcp-server-readme): Automatically generate an MCP server from your API docs with ReadMe, and give agents the ability to search, understand, and execute your APIs directly from the tools developers already use.
- [Improve Documentation Quality at Scale with ReadMe's Docs Audit](https://readme.com/blog/improve-documentation-docs-audit): Docs Audit helps teams identify gaps, enforce standards, and improve API documentation without manual reviews.
- [Find & Fix API Documentation Errors with ReadMe's AI Linter](https://readme.com/blog/find-and-fix-api-documentation-errors-with-readme-ai-linter): Define your own style guide, flag errors, and fix issues with an AI writing assistant.
- [Team Up with AI to Build Docs](https://readme.com/blog/team-up-with-ai-to-build-docs): ReadMe's AI launch includes a writing assistant, a built-in linter, a docs audit, and a new search experience.
- [Use ReadMe’s AI Tools to Write Great Documentation](https://readme.com/blog/ai-tools-for-api-documentation): Learn how to use ReadMe’s AI tool to write, review, and improve your API docs.
- [Interactive API Documentation: How to Use Custom Components in ReadMe](https://readme.com/blog/component-marketplace): Learn how to add interactive React components into your docs.
- [Review & Approve API Documentation Changes with Branch Reviews](https://readme.com/blog/branch-reviews): See changes, review updates, and approve edits before your API docs go live.
- [Ship Docs Like Features with Branching](https://readme.com/blog/branches): Edit, preview, and publish branches in ReadMe for full version control of your docs no matter where you work.
- [Where Docs-as-Code Goes Next](https://readme.com/blog/docs-as-code): Bringing Git to ReadMe so that you can commit to the best of both worlds.
- [From IDE to AI: How ReadMe bridges APIs to LLMs with MCP](https://readme.com/blog/mcp-servers): What ReadMe's support for MCP means for developers and how to edit docs right from your IDE.
- [AI Meets API Docs: The Why Behind /llms.txt](https://readme.com/blog/ai-meets-api-docs): LLMs are changing how people learn about APIs. Now your docs will remain central to the experience.
- [Challenge Coins and Company Credits](https://readme.com/blog/developing-company-culture-as-a-startup): The story behind ReadMe's challenge coins and our Credits page, and how they helped us build company culture.
## Resources
- [What "LLM-Ready" Actually Asks of Your Team](https://readme.com/resources/what-llm-ready-asks-of-your-team): Making your docs LLM-ready sounds like a project. It's closer to a habit, and that's the harder part.
- [Why More Context Can Make an AI Doc Agent Worse](https://readme.com/resources/more-context-worse-agent): The instinct is to give the agent everything. The better drafts come from giving it the right thing.
- [Teaching an AI Agent Your Page Templates, Not Just Your Words](https://readme.com/resources/teaching-an-agent-your-templates): A style guide tells an agent how to write a sentence. It says nothing about how your pages are shaped. That second thing is where drafts go wrong.
- [What to Do When the AI Agent Drafts the Wrong Thing](https://readme.com/resources/when-the-agent-drafts-wrong): A wrong draft isn't a failure of the system. It's the moment the system is supposed to catch.
- [Writing Answers a Model Will Quote Word-for-Word](https://readme.com/resources/answers-a-model-will-quote): A model doesn't quote your page. It quotes one sentence from it. Write that sentence on purpose.
- [How to Review AI-Drafted Doc Changes Without Rubber-Stamping](https://readme.com/resources/reviewing-ai-drafted-doc-changes): An AI writer opening branches for you is only half the workflow. The other half is reviewing the draft like you mean it.
- [When to Let the AI Agent Draft, and When to Write It Yourself](https://readme.com/resources/when-to-let-the-agent-draft): An AI agent is great at mechanical work and bad at strategy. Knowing the difference is the skill that makes it useful.
- [Measuring Whether Your AI Documentation Workflow Is Actually Working](https://readme.com/resources/measuring-ai-doc-workflow): The count of AI-generated drafts isn't the metric. Time-to-merge, miss rate, and support deflection are.
- [Using an AI Agent to Add Interactive Components to Docs](https://readme.com/resources/ai-agent-interactive-components): Interactive components only help if you remember to use them. An AI agent that knows your component library can do the remembering for you.
- [Connecting an AI Writer to Your Spec, Not Just Your Code](https://readme.com/resources/ai-writer-meets-openapi-spec): A diff-only AI writer sees what changed. A spec-aware writer also knows what the change means. The difference is whether the drafts are correct.
- [What Makes a Doc Page Cite-Able by an AI Engine](https://readme.com/resources/cite-able-doc-pages-for-ai-engines): When ChatGPT or Perplexity answers a question, it picks one page to cite. Here's what makes that page yours.
- [Prompting Patterns That Work with a Docs-Grounded AI Agent](https://readme.com/resources/prompting-patterns-docs-agent): A grounded agent rewards specific prompts. Here are the patterns that consistently produce drafts you can ship.
- [When an AI Writer Should and Shouldn't Propose a Change](https://readme.com/resources/when-ai-writer-should-propose): A well-tuned AI writer stays quiet on most PRs. The signal is in the restraint.
- [How an AI Agent Uses Your Existing Docs as Context](https://readme.com/resources/ai-agent-existing-docs-as-context): Grounding an agent in the rest of your docs is what stops it from inventing endpoints and contradicting nearby pages.
- [Mapping Code Changes to Documentation Impact](https://readme.com/resources/mapping-code-changes-to-doc-impact): An AI writer is only as good as its ability to figure out which doc pages a code change affects. The mapping is the hard part.
- [Why an AI Documentation Agent Needs Your Style Guide](https://readme.com/resources/ai-agent-grounded-in-style-guide): An agent that doesn't know your style guide produces output that has to be rewritten. An agent that knows it produces output you can ship.
- [Building Doc Pages That Survive Being Chunked](https://readme.com/resources/doc-pages-that-survive-chunking): An AI engine rarely reads the whole page. A few patterns keep your content useful when only one section gets retrieved.
- [Designing the Review Workflow for AI-Generated Documentation](https://readme.com/resources/ai-writer-review-workflow): Auto-merging AI drafts into your docs is how trust dies. A two-stage review keeps speed without giving up quality.
- [Using an AI Agent to Rewrite Documentation for Clarity](https://readme.com/resources/ai-agent-rewriting-docs-for-clarity): Generic AI invents. A docs-grounded agent rewrites. The difference is what the model knows before it starts.
- [Comparing Ways to Give an API to an LLM](https://readme.com/resources/giving-an-api-to-an-llm): Spec-in-prompt, retrieval, function calling, and MCP. Trade-offs and when to pick each.
- [How an AI Writer Detects Documentation Drift from a Pull Request](https://readme.com/resources/ai-writer-detecting-doc-drift): A PR-triggered AI writer reads the diff, decides whether any docs are affected, and drafts the update. Here is what the loop actually does.
- [Measuring How Many Past Support Tickets Your Docs Could Have Answered](https://readme.com/resources/replay-tickets-against-docs): A retrospective evaluation that replays resolved tickets against the current docs and reports what would have been self-serve.
- [Schema.org Markup for API Docs in the Age of AI](https://readme.com/resources/schema-org-for-api-docs): A short tour of the schema types worth adding to API docs, why they matter for AI engines, and how to keep them in sync with the page.
- [Common Documentation Patterns That Cause Agents to Fail on an API](https://readme.com/resources/agent-failure-patterns): A short catalog of doc patterns that work for humans but break agents, with a fix for each.
- [How llms.txt Works, and What to Put in One for an API](https://readme.com/resources/llms-txt-for-apis): A short field guide to writing an llms.txt for a developer-facing product, plus a sample.
- [Turning Support Tickets into Documentation Updates with an LLM in the Loop](https://readme.com/resources/tickets-to-doc-updates): A simple workflow that turns resolved tickets into draft doc updates, without taking humans out of the loop.
- [What GEO and AEO Mean for Developer Documentation](https://readme.com/resources/what-geo-aeo-means): A primer on Generative Engine Optimization and Answer Engine Optimization, and how the practice applies to API docs specifically.
- [Optimizing Docs for ChatGPT, Claude, and Perplexity](https://readme.com/resources/optimizing-for-chatgpt-claude-perplexity): Each engine finds and reads your docs in a slightly different way. The differences matter when you want to show up on a specific surface.
- [What LLMs Tend to Hallucinate When API Docs Are Incomplete](https://readme.com/resources/llm-api-hallucinations): A checklist of the most common invented details, useful when reviewing a reference for gaps.
- [How Agents Pick Which Version of Your Docs to Read, and How to Influence It](https://readme.com/resources/doc-versions-and-agents): Stale doc versions reach agents through training data, search caches, and version routing. Each has a different way to push them toward current docs.
- [How Stale Documentation Affects Token Usage and Agent Behavior](https://readme.com/resources/stale-docs-token-cost): When docs lag behind the API, agents do not just fail. They retry, escalate, and burn tokens trying to recover.
- [Using Your API Docs as an Evaluation Set for LLMs](https://readme.com/resources/api-docs-eval-set): Every code example in your docs is a task and an expected answer. Score how well a model uses them and you have a working benchmark for both the model and the docs.
- [Writing Documentation That Works for Both Humans and Language Models](https://readme.com/resources/writing-for-humans-and-models): There is no separate style for AI-friendly docs. The same things that make a reference clear for a careful reader make it usable for a model.
- [MDX Cheat Sheet and Quick Reference Guide](https://readme.com/resources/mdx-cheat-sheet): Good technical d
