Building with the API? Open the developer docs
Finmagine API & MCP — free tier to test • Pro/Max for full access • REST + MCP
Master llms.txt and agent discovery through a complete learning overview and interactive flashcards
Every AI agent that wants to use Finmagine programmatically faces the same first problem: how does it even know Finmagine's API exists, and where does it start? llms.txt is Finmagine's answer — a single, plain-text file at the root of the domain that an agent can fetch first, before it reads a single line of documentation, to get a curated map of everything worth knowing.
robots.txt and sitemap.xml don'tClick any card to reveal the answer. Use the search box to find a specific topic.
llms.txt is a proposed web convention — a plain-text, markdown-formatted file published at the root of a domain (https://finmagine.com/llms.txt) whose entire job is to give AI agents and LLM-based tools a curated, high-signal map of a site's most important machine-readable and agent-relevant resources.
The name deliberately echoes robots.txt, and the parallel is intentional: both are small text files sitting at a predictable URL that exist purely to help automated visitors behave sensibly. But they solve completely different problems, which is worth being precise about before going further.
llms.txt is the site owner's own curated shortlist of those URLs, in the order and grouping the owner thinks makes sense, instead of making an agent guess by crawling everything or scraping a sitemap full of noise.
| Question | Answer |
|---|---|
| Where does it live? | The domain root — /llms.txt, same predictable location as /robots.txt |
| What format? | Plain markdown — headings, a short summary, and grouped bullet lists of links with one-line descriptions |
| Who reads it? | AI agents, agent frameworks, and LLM-based tools — not search engine crawlers, and not humans browsing directly |
| Is it required? | No — it's a voluntary convention, not an enforced standard or a search-ranking signal |
https://finmagine.com/llms.txt as plain text over HTTP, the same way it would fetch any other URL. The value is entirely in the file being small, curated, and consistently structured — cheap for an agent to read in full and reason about immediately.
Finmagine's REST + MCP API currently exposes 86 operations (60 India-market and 60 + 26 US-market operations, to be precise about the current split) covering screening, company research, market breadth, technical scans, and two full multi-agent research systems. That is a genuinely large surface — far too much for an agent to reliably discover by crawling the website's HTML, and far too much to expect a developer to hand-summarise correctly every time the API grows.
Without a curated entry point, an agent (or the person configuring one) is left with bad options: scrape the marketing pages and hope the API is mentioned somewhere, guess at conventional paths like /api or /docs, or rely on a human to manually paste in a list of URLs that goes stale the moment a new endpoint ships. llms.txt replaces all three with one authoritative, versionable file.
llms.txt exists for a narrower, newer problem: an agent that already knows it's on finmagine.com and needs to figure out, in one fetch, exactly which of the site's resources are safe and useful to act on programmatically.
The file opens with a one-paragraph summary of what Finmagine is, then breaks into five grouped sections: API & Agent Access, Core Research Tools, Guides, Reference, and Optional. Every entry is a markdown link with a short description — enough for an agent to decide whether to follow it without needing to fetch it first.
Here is the actual, live content of Finmagine's llms.txt as of this guide's publish date — reproduced in full so you can see exactly what an agent sees on its first fetch.
This is the group an agent framework cares about first. Notice the deliberate ordering: openapi.json comes before the human-readable docs, because a framework capable of ingesting an OpenAPI URL directly should be pointed there immediately rather than being routed through prose. agent-recipes.json comes right after — it exists specifically so an agent doesn't have to guess which tools compose into a working chain; the ARCH decision behind it was "give agents a working recipe instead of 86 unconnected tools."
openapi-compact.json strips it down to just operation ID, path, tier, and required params — enough for an agent doing lightweight routing (e.g. "which endpoint handles this?") without loading the full contract into context. Two different jobs, two different files.
These are the actual product surfaces — the screeners and Strategy Lab — for an agent that needs to point a human at a live page rather than call an API directly, or that wants context on what the underlying product does before calling the equivalent API operation.
The last three sections are lower-priority but still curated: feature guides (the same collection this post belongs to), reference material an agent might need to interpret a response (like the Financial Glossary, for explaining a ratio it just fetched), and genuinely optional links like the consumer subscription pricing page — clearly separated from API/MCP pricing so an agent doesn't conflate the two completely different tier systems.
There's no special protocol here — just a predictable sequence a well-built agent (or the person configuring one) follows:
https://finmagine.com/llms.txt as plain text — a single, cheap HTTP GET, no auth required.openapi.json straight away. An agent that needs a human-readable getting-started flow follows /developer/docs.php instead. An agent trying to compose a multi-step workflow without guessing follows agent-recipes.json.X-Api-Key header), and every operation still respects its own tier gate (Free / Pro / Max). The file only solves discovery, not authentication or authorization.
Say you're building an autonomous research agent and you tell it: "Finmagine has data on Indian and US stocks — figure out how to use it." A well-built agent framework would:
finmagine.com/llms.txt and see the API & Agent Access sectionopenapi.json to get the full 86-operation contractagent-recipes.json is listed right alongside it and load that too, since it explicitly promises "verified-executable multi-tool workflows"india_momentum_setup for a momentum screen) instead of trying to compose 4 separate tool calls from scratch and hoping they chain correctlyThat's the entire value proposition in one sentence: llms.txt turns "figure out how to use this site" into "read one small file and follow the pointer."
Finmagine publishes all three, and it's worth being precise about what each one is actually for — they're easy to conflate because they're all small text files at predictable root-level URLs, but they solve unrelated problems.
| File | Audience | Purpose | Affects SEO? |
|---|---|---|---|
/robots.txt | Search engine crawlers | Tells crawlers which paths they may or may not index | Yes — directly controls indexing |
/sitemap.xml | Search engine crawlers | Exhaustive list of every indexable URL, for discovery and ranking | Yes — helps crawlers find everything |
/llms.txt | AI agents & agent frameworks | A small, curated, human-written map of the resources that actually matter for programmatic/agentic use | No — it's not read by search engines and carries no ranking signal |
llms.txt is deliberately the opposite: a handful of high-value entries, hand-picked, because an agent benefits from NOT having to sift through hundreds of irrelevant URLs to find the openapi.json link.
llms.txt gets you to the front door. The next two guides in this cluster cover what's immediately behind it:
From there, the series moves into the two zero-code Explorer tools, BYO LLM key setup, and the flagship Investment Committee and Research Preset workflows — see the API & Agent Integration hub for the full roadmap.
Finmagine gives you 30+ computed financial ratios, sector benchmarks, FII/DII flows, the Finmagine Score, and AI-powered analysis — all in one place.