What Changed: A Retrieval Layer Built for Coding Agents
Coding agents spend a large share of their tool calls searching for three things: the repository that implements an idea, the documentation page that answers a question, and the issue or pull request where a bug was fixed. That context is scattered across GitHub, docs sites, and threads, and existing retrieval options are lexical, incomplete, or both.
On August 20, 2026, Firecrawl launched the Developer Index, a specialized index for coding agents. It indexes the artifacts agents actually need to write working, current code: READMEs, external documentation, issues, pull requests, and OpenAPI specs, with semantic retrieval and metadata filters, refreshed daily. The index contains 70M+ artifacts, including issues and pull requests from top repositories, READMEs from a broad set of public repositories, external documentation sources (Stripe and similar), OpenAPI specs, and popular skill repos. Every artifact carries metadata such as stars, licenses, and artifact type.
To be clear about what it is not: the Developer Index does not store code, and it is not a general web search endpoint. It is a purpose-built retrieval layer organized around the artifacts coding agents produce and consume.
Alongside the index, Firecrawl released DevDex, an open benchmark of 1,179 developer-search queries scored on Recall@10 and MRR@10, so teams can measure how well any retrieval system supports real coding-agent workflows.
Why a Specialized Index? The Gap It Fills
Firecrawl observed three recurring patterns among customers searching and scraping for developer content:
- Agentic products (like Lovable, Replit, Bolt) doing backend debugging on behalf of end users.
- Knowledge-base builders stitching internal and external repos into a single retrieval layer.
- Frontier labs needing open developer documentation, code, issues, and PRs as training and evaluation data.
All three were working around the same gap. Existing providers weren’t designed for a world of agents: search is lexical, not semantic, and getting complete artifacts (a README plus its issues plus its recent PRs) meant stitching together 50+ API calls, or building the whole pipeline from scratch. Even Firecrawl’s general search and scrape gave subpar results for this shape of query, because a coding agent doesn’t want a web page, it wants an artifact.
The Developer Index is that artifact layer.
How It Works: API, CLI, MCP, and SDKs
You send a natural-language question to the Firecrawl Developer Index and get back ranked developer results with the passages that matched, so an agent can act on the answer without a second scrape. There are two ways to reach it:
- Firecrawl
/search/developerreturns developer sources only, with result-type, repository, and documentation-source filters. This is the surface to reach for when you want ranked developer results with matched passages. - Firecrawl
/searchwithcategories: ["developer"]returns Developer Index results through the standard/searchresponse, in the same shape as ordinary web results.
Every result carries a stable id (like issue:owner/repo#123) whose prefix tells you the artifact kind (doc:, issue:, pull_request:, or readme:), a url, and its matched passages in markdown, so tables and code blocks survive. Through the API, filters let you scope by types, repos, sources, language, topic, license, min_stars, and more. You can also set skills: "only" to search indexed agent-skill files. These filters are API-only: on the CLI and MCP, agents perform best without them, so they are intentionally not exposed there.
No Firecrawl API key is needed to get started; add one for higher rate limits. A developer search costs 2 credits per 10 results, rounded up.
# No API key needed to get started; add -H "Authorization: Bearer $FIRECRAWL_API_KEY" for higher rate limits:
curl -s "https://api.firecrawl.dev/v2/search/developer?query=how%20do%20I%20configure%20retries&k=10"The easiest way to give your agent access is Firecrawl’s dedicated developer skill, which plugs into the Firecrawl CLI or MCP server:
npx -y firecrawl-cli@latest setup developer-indexFor the full parameter reference and response schema, see the Developer Index docs.
DevDex Benchmark: How It Performs
DevDex is an open benchmark for developer-search retrieval, scoring how well any system returns the right docs, GitHub pages, and Stack Overflow answers for real coding-agent queries. It was built because standard search benchmarks don’t reflect what agents actually look up while writing code.
The benchmark includes 1,179 developer-search queries across three tracks that mirror how coding agents actually retrieve:
- Repository discovery. Find the repo that matches a described capability without knowing its name. Example: “a library for incremental PDF parsing.”
- Documentation lookup. Find the exact page that answers a how-to. Example: “How do I add Pydantic to my project using uv instead of pip?”
- Issue and PR resolution. Find where a specific bug was discussed and fixed. Example: “scikit-learn LogisticRegression random_state not working.”
Each track is scored deterministically on Recall@10 and MRR@10 against fixed gold references, with a memorization check to drop any query the driver model can answer from pretraining. Every provider runs under a matched setup: same driver model (Claude Opus 4.8), one search tool active per run, same harness.
Recall@10 measures whether the correct artifact appears anywhere in the top ten results. Higher is better. Each overall score is the mean across the three tracks. The Firecrawl Developer Index scores 0.63, ahead of Firecrawl Search (no category) at 0.58, Parallel at 0.57, and Mintlify and Exa at 0.54. Native web search sits at 0.45, and Context7 at 0.17.
Broken out by track, the Firecrawl Developer Index leads issue and PR resolution at 0.66, and is statistically tied with Context7 on documentation lookup (both at 0.47, a 0.006 gap well inside the 95% CI). Context7 is docs-focused, and scores near zero on the other two tracks (0.01 on repository discovery, 0.03 on issues and PRs). On repository discovery the Developer Index posts 0.76, behind Parallel at 0.82 and Firecrawl Search at 0.78.
The gap between the “no tools” control and every other row is the size of the retrieval problem: coding agents can’t answer these queries from pretraining alone. The gap between native web search and the specialized indexes is what a purpose-built artifact layer buys you.
Firecrawl is open-sourcing half of the dataset plus the evaluation harness so any team can reproduce results on their own systems. To submit a provider, open a PR against the repo with your results on the public half, and email rafael@sideguide.dev with valid API keys so they can rerun on the held-out half.
Practical Use Cases for Product Builders
- Ship an agentic product that debugs its own code. Wire the Firecrawl Developer Index into your agent’s tool loop and let it search issues and PRs the moment it hits an error, instead of guessing.
- Build a developer knowledge base. Use the Firecrawl Developer Index to pull external documentation and repo artifacts alongside your internal sources, without maintaining a GitHub scraper.
- Train or evaluate coding models. Use the Firecrawl Developer Index as a retrieval layer for RAG-style training data pipelines, and use DevDex to score whatever retriever you build.
Limitations and Trade-offs
While the Developer Index leads overall recall, it is not the best at every track. On repository discovery, it trails Parallel and Firecrawl Search. For documentation lookup, it ties with Context7, which is docs-only and scores near zero on other tracks. The index does not store code, so if you need code-level retrieval, this isn’t the tool. Also, the API filters are not exposed on CLI and MCP, which may be a limitation for users who want to scope searches from those interfaces. Finally, the benchmark is new, and while it’s open, it’s Firecrawl’s own benchmark; independent validation is still emerging.
Takeaway: A Public Standard for Developer Search
Firecrawl Developer Index is available now in the API, CLI, MCP, and SDKs. It plugs into any harness you already run, including Codex, Claude Code, and Grok Build. The combination of a specialized artifact index and an open benchmark like DevDex gives product builders a way to measure and improve retrieval for coding agents. If you’re building an agent that depends on developer documentation, this index is worth trying—especially when general search fails to deliver artifact-level results.
Sources
AI-assisted summary compiled from the sources above, reviewed by a human before publishing.