CRW vs Firecrawl vs Tavily: 200-Query Benchmark (Search + Scrape)

We benchmarked CRW, Firecrawl, and Tavily head-to-head on both search and scrape — 100 search queries and 101 scrape URLs, all run concurrently against all three providers. Same queries, same URLs, same conditions.

The results speak for themselves.

Search: CRW Dominates (100 Queries)

CRW won 73 out of 100 search latency races — more than Firecrawl and Tavily combined.

CRW is 2.3x faster than Tavily on average and consistently faster than Firecrawl across all percentiles. Tavily managed only 2 wins out of 100 — both on outlier queries where all providers were slow.

Scrape: CRW Outpaces Firecrawl by 2.2x (101 URLs)

On scraping, CRW's lightweight Rust-based renderer delivers 2.2x faster median latency than Firecrawl while still handling JavaScript-heavy pages that simpler extractors can't.

CRW is faster than Firecrawl on every single latency metric — average, median, and P95. The median gap is the most telling: 255ms vs 557ms. That's the difference between "instant" and "noticeable" in a user-facing application.

The Full Picture: CRW's Unique Position

CRW is the only provider that leads in both search and scrape speed:

What We Tested

Search: 100 Queries Across 10 Categories

We designed a dataset of 100 queries spanning 10 distinct categories to simulate real-world AI agent usage patterns:

Scrape: 101 URLs Across Major Categories

We scraped 101 URLs spanning frameworks (React, Vue, Svelte, Angular), languages (Rust, Go, Python, TypeScript, Zig), databases (PostgreSQL, Redis, MongoDB), cloud providers (AWS, GCP, Azure), AI tools (OpenAI, Anthropic, HuggingFace), and developer productivity tools (Figma, Linear, Notion).

Why CRW Is Faster

CRW's speed advantage comes from architectural decisions, not tricks:

• Single-binary Rust core: 6.6 MB idle RAM. No JVM, no Python runtime, no Node.js overhead. Just fast compiled code handling your requests.
• LightPanda renderer: A Rust-based browser engine that handles JavaScript rendering at a fraction of Chromium's resource cost. This is why CRW scrapes at 255ms median while Firecrawl's Chromium-based approach takes 557ms.
• Multi-engine aggregation: CRW's search queries multiple engines simultaneously — the fastest response wins. This is why search latency is so consistent.
• Minimal processing overhead: Results are normalized and scored at the edge with minimal transformation. No AI post-processing on the hot path.

What This Means for AI Agents

If you're building AI agents that search and scrape the web, latency compounds fast:

• 10 searches per agent run: CRW saves 11.2 seconds vs Tavily (8.8s vs 20s)
• 100 pages scraped per pipeline: CRW saves 30 seconds vs Firecrawl (25.5s vs 55.7s)
• At 100 agent runs per day: That's 18+ minutes of wall-clock time saved daily on search alone

And because CRW supports search + scrape in a single API call, you can eliminate an entire round-trip that most agent architectures currently require:

import CRW from 'crw-js';

const crw = new CRW({ apiKey: 'your-key' });

// Search and scrape in one call — no separate scraping step
const results = await crw.search({
  query: "latest transformer architecture improvements",
  limit: 5,
  scrapeOptions: {
    formats: ["markdown"],
    onlyMainContent: true,
  },
});

// Each result includes full markdown content
for (const r of results.data) {
  console.log(r.title, r.markdown?.length, "chars");
}

Methodology

Full transparency on how we ran this:

• 100 search queries across 10 categories + 101 scrape URLs across major web categories
• Concurrent execution: All 3 providers tested simultaneously per URL/query via Promise.all — no sequential advantage for any provider
• 5 results per search query for all providers
• Tavily advanced search depth — we used Tavily's best mode, not basic
• Markdown format for scrape results across all providers
• Single run from the same network location, same time of day
• Full results: 124KB JSON report with per-URL and per-query data

The benchmark script, dataset, and full results are open source. Run it yourself — we encourage independent verification.

Try It Yourself

CRW's Search and Scrape APIs are live with 500 free credits — no card required.

# Search — 2.3x faster than Tavily, 73% win rate
curl -X POST https://fastcrw.com/api/v1/search \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "best search API for AI agents", "limit": 5}'

# Scrape — 2.2x faster than Firecrawl, JS rendering included
curl -X POST https://fastcrw.com/api/v1/scrape \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com", "formats": ["markdown"]}'

Or self-host the entire stack for free. Same APIs, your infrastructure.

Frequently Asked Questions

Is CRW a drop-in replacement for Firecrawl?

Pretty close. CRW's API is Firecrawl-compatible: same endpoint patterns (POST /v1/scrape, POST /v1/search), same JSON body structure. Migration is typically under 15 minutes — change the base URL and API key, and you're done.

How does CRW handle JS-heavy pages?

CRW uses LightPanda, a lightweight Rust-based browser engine that renders JavaScript without the resource overhead of Chromium. This is why CRW achieves 255ms median scrape latency — it gets the benefits of JS rendering without the weight of a full browser.

How does pricing compare?

CRW Standard ($69/mo) gives 100K credits. Firecrawl Growth ($188/mo) gives 100K credits. Tavily Researcher ($100/mo) gives 12K searches. CRW is approximately 6x cheaper per search than Tavily and significantly cheaper than Firecrawl at equivalent tiers. Plus, CRW can be self-hosted for free.

Can I run the benchmark myself?

Absolutely. Run bun benchmarks/triple-bench.ts from the repo. Add your own API keys and verify independently. The full dataset and results JSON are included.