Firecrawl gives your agent clean web data. Human Browser gives your agent hands.

Two categories, not two vendors

Firecrawl (firecrawl.dev) is an extraction and scraping API — you POST a URL, you get clean markdown or structured JSON back, optimized for RAG ingestion. It is the pivot product from Mendable, YC S22, Series A in August 2025 ($14.5M led by Nexus), with 145K GitHub stars and 1.25M developers. Customers include Shopify, Apple, DoorDash, Canva, Zapier, and Replit. Their endpoints — /scrape, /search, /crawl, /map, /interact — are the reference shape for "power AI agents with clean web data." When the job is "URL in, LLM-ready content out," Firecrawl is the tool.

Human Browser is a different category — a cloud agent runtime. You POST a goal described in natural language, and an LLM loop drives a real Chrome browser to accomplish it: log in, navigate the dashboard, filter the report, download the CSV, verify the artifact. Managed Chrome on Xvfb, residential connection per session, captcha solving billed only on success, live viewer with one-click human takeover, CUA + DOM hybrid execution auto-routed per site, and a per-site knowledge base that auto-tunes across 277+ recorded trajectories. Where Firecrawl gives your agent clean web data, we give your agent hands.

The honest framing is "complementary, not competitive." A production AI-agent stack today usually needs both: Firecrawl to ingest the well-behaved 96% of URLs into RAG, Human Browser to accomplish the tasks that require actuation — logins, multi-step flows, sites Firecrawl's Stealth Mode still chokes on. Route per URL, keep the LLM the same, ship faster.

What Firecrawl does not ship (and does not try to)

None of that is criticism of Firecrawl's scope. An extraction API should be an extraction API. It is a description of the surface area above the URL boundary — the place where a task requires actuation rather than ingestion — and that is where Human Browser is built to live.

Use both together: the routing pattern

What you get from the runtime layer

• Self-serve: try it for $1, no demo call. Top up from $5, balance never expires.
• Public per-line-item pricing — $0.10/browser-hour, $4/GB residential connection, $0.005 per solved interactive challenge, $0.02 per agent step with the AI included. Median task on our production: about 8 agent steps, $0.24 all-in (Sep 2026).
• Open-source core — @virixlabs/humanbrowser on npm (Apache-2.0). Run the same runner locally for free, point at the cloud only when you need shared infra.
• CUA + DOM hybrid execution — Computer-Use-Agent path (xdotool + scrot on Xvfb) for canvas-heavy, drag-and-drop, or shadow-DOM-heavy targets; cheap DOM path for the rest. Auto-routed per domain via the knowledge base.
• native A2A (v0.3) endpoint — agent.humanbrowser.cloud/a2a plus discoverable agent card at /.well-known/agent-card.json. Claude Code, Codex, LangGraph, CrewAI, OpenAI Agents SDK, Google ADK all plug in straight.
• Live viewer + human takeover — MJPEG preview per session, one-click HITL takeover, free. Built for user-authorized tasks where a human stays in the loop.
• Public benchmarks — 6 cloud-browser engines × 12 LLMs, raw data + methodology at github.com/VirixLabs/stealth-benchmark. Plus our LLM cost-perf benchmark found google/gemini-2.5-flash-lite at $0.023/agentic task as the cost-leader.
• Self-improving per-site knowledge base — every successful task writes structured notes that the next session loads before planning.

Pricing — where each tool wins on cost

This is the honest split. If your workload is bulk static content ingest at 100k+ pages/month, Firecrawl's per-credit economics beat almost anything else in the category — that is why they closed a Series A and count Shopify, Apple, and DoorDash as customers. If your workload is "the agent must actually do the task" — log in, navigate, extract, download, verify — Human Browser's $0.10/minute plus a real agent loop is the cheaper end-to-end path because you are not paying Firecrawl's Stealth Mode 5× multiplier per page while still writing your own scripted actions on top.

Public benchmarks — what we publish at the runtime layer

Extraction-layer benchmarks are Firecrawl's job — pages/second, markdown fidelity, RAG ingestion cleanliness. Runtime-layer benchmarks (which engine survives which site, which LLM is the cost-leader for agentic tasks, which trajectories reuse across runs) are only meaningful when you operate the agent loop. We do, so we publish them.

When Firecrawl is the better choice

This page exists to help you make a real decision, not to win every comparison. Firecrawl is the better tool for these:

• Bulk static content ingest into RAG. Thousands of public docs, blog posts, product pages, into markdown at 1 credit/page. This is the shape Firecrawl was built for and they solved it well.
• Sites without login walls or aggressive anti-bot. Their default scrape handles the well-behaved 96% of the public web faster and cheaper than a full agent loop would.
• Cost sensitivity at high volume. $99/month for 100k credits (Standard) is genuinely industry-leading — an agent runtime cannot match that per-page price for content that does not require actuation.
• LLM-ready markdown as your canonical output. Firecrawl's markdown pipeline is the reference implementation. If your downstream is a RAG index, use Firecrawl.
• Search-style crawling. /search at 2 credits per 10 results, /map, /crawl — Firecrawl's endpoints are shaped for the discovery-and-ingest pattern.

When Human Browser is the better choice

• Authenticated multi-step flows. Log in, navigate the dashboard, filter, export, verify — a full agent loop with cookie persistence per profile, not a scripted actions array.
• Goal-in-natural-language tasks. "Log in to target.com and export last week's CSV" — the LLM plans each step at inference time, adapts when the DOM changes, retries when a captcha appears.
• Sites where Firecrawl's Stealth Mode still chokes. Deep PerimeterX / DataDome / press-hold targets — the 4% tail where extraction APIs get expensive or fail outright.
• Live viewer + HITL takeover as a first-class workflow. Free on every session. Built for user-authorized tasks where a human stays in the loop.
• A2A-first integration. Your agent already speaks Agent2Agent — Human Browser is reachable as another agent, not as an SDK you import.
• CUA for canvas / drag-and-drop / shadow-DOM sites. Auto-routed per domain from a 277+ trajectory corpus. No config flag flipping.

Code: Firecrawl scrape vs Human Browser A2A vs the hybrid router

const res = await fetch('https://api.firecrawl.dev/v2/scrape', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer ' + process.env.FIRECRAWL_API_KEY
  },
  body: JSON.stringify({
    url: 'https://docs.example.com/guide',
    formats: ['markdown']
  })
});
const { data } = await res.json();
// data.markdown → clean LLM-ready content.
// 1 credit. Right tool for well-behaved public pages.

const res = await fetch('https://agent.humanbrowser.cloud/a2a', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer ' + process.env.HB_TOKEN
  },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 'export-1',
    method: 'tasks/send',
    params: {
      skill: 'login_and_extract',
      message: 'Log in to target.com and export last week CSV',
      country: 'gb',
      profile: 'reports-bot'
    }
  })
});
const { result } = await res.json();
// result.artifacts has the CSV. LLM planned each step,
// residential connection, live viewer, HITL if it stalls.

// The pattern most production stacks end up on:
// Firecrawl for the 96%, Human Browser for the 4%.

const HOSTILE = ['zillow.com', 'ticketmaster.com', 'linkedin.com'];
const NEEDS_AUTH = shouldUseHB(url);  // your policy

async function fetchForAgent(url, goal) {
  const host = new URL(url).hostname;
  const hostile = HOSTILE.some(h => host.endsWith(h));

  if (NEEDS_AUTH || hostile) {
    // Actuation path — cookies, multi-step, live viewer.
    return callHumanBrowser({ goal, url });
  }
  // Ingestion path — 1 credit, clean markdown.
  return callFirecrawl({ url, formats: ['markdown'] });
}

// One code path. Two backends. Full coverage.
// Same LLM agent consumes whatever comes back.

Left: Firecrawl at what it does best — clean markdown at 1 credit/page. Middle: Human Browser at what we do best — a goal declared once, the artifact returned after the agent actually accomplishes the task. Right: the router most teams eventually write, sending each URL to whichever tool is the right fit. That is the shape we designed the two products to live in.

FAQ