Both give you scrape, crawl and map on a credit balance — only one of them lets you keep the browser.
Choose Firecrawl when the job is “turn a lot of URLs into LLM-ready text”. That is what its scrape, crawl, map, search and agent endpoints are built for, it is genuinely open source under AGPL-3.0 with a first-party self-hosting guide, and it publishes its per-plan rate limits, concurrency ceilings and queue depths instead of hiding them behind a sales call.
Choose Wayfern when the work needs a browser you can hold. Wayfern ships the same shape of Web Data API — scrape at 1 credit per page, crawl at 1 credit per successfully crawled page, map at 2 credits per started block of 10 URLs — but it also hands you the raw Chrome DevTools Protocol at wss://browser.wayfern.com/ws, where one browser keeps its cookies, its DOM and its residential exit IP for the whole run at 8 credits per open-page hour (minimum 60 seconds billed per page).
The dividing line is state. A logged-in flow, a multi-step form, or anything that has to look like one continuous person from one city needs a session that survives between steps. Five million product pages flattened into markdown does not — and for that, an endpoint that already returns markdown, JSON, screenshots and a summary in one call is the shorter path.
A context API discards the browser between calls; a CDP session keeps one browser — and one identity — for the whole run.
Firecrawl’s primitives are per-request. You hand it a URL and get back content, and it handles JS rendering, proxy rotation, anti-bot handling and document parsing on your behalf. It does document a Browser Sandbox for “managed browser sessions for interactive workflows”, an Interact endpoint that runs write, press, click, wait and screenshot actions against a page, and an Agent endpoint that navigates for you from a natural-language brief — so scripted interaction is available; it is just expressed as actions attached to a request.
Wayfern’s gateway is the browser itself. `BrowserGateway` authenticates a link token on the WebSocket URL, reserves a slot in the container pool, and proxies Chrome DevTools Protocol traffic straight through, so `chromium.connectOverCDP()` or `puppeteer.connect()` drive a real Chromium you opened and keep until you close it. Anything CDP can do — intercepting requests, injecting scripts before document start, reading a service worker, stepping through a checkout — is available, because nothing is wrapping it.
That is also why the exit selectors live on the connection string rather than on each call: `?country=®ion=&city=&isp=&session=` pins the residential exit for the lifetime of that session, so step four of a flow leaves from the same address as step one.
Wayfern cells are checked against apps/manager in this repository. Firecrawl cells come from its own documentation, linked in full below; anything its docs do not state is marked rather than guessed.
| Capability | Wayfern | Them |
|---|---|---|
| URL → markdown | POST /api/v1/scrape returns markdown, HTML, rawHtml, links and metadata. 1 credit per page. | Scrape converts any URL to markdown, HTML, screenshots or structured JSON. 1 credit per page. |
| Formats in a single call | markdown, html, rawHtml, links, screenshot, pdf, json, summary. screenshot/pdf/json add +4 credits once per page however many are asked for; summary adds +2. | markdown, summary, html, rawHtml, screenshot, links, json, images, branding, product, audio, video, and query — natural-language Q&A over the page content. |
| Whole-site crawl | POST /api/v1/crawl returns a job id immediately, then bills 1 credit per successfully crawled page. Polling is free; results paginate with skip/limit, failures have their own endpoint, and a cancel leaves crawled pages readable. | Crawl walks an entire website and returns content from all pages. 1 credit per page; Monitor re-checks at 1 credit per page per check. |
| URL discovery | POST /api/v1/map reads sitemaps first, page links second. 2 credits per started block of 10 returned URLs. | Map discovers all URLs on a website. 1 credit per page. |
| Raw CDP endpoint you attach Playwright to | wss://browser.wayfern.com/ws?token=… is the CDP socket itself. connectOverCDP() or puppeteer.connect() drive the session directly, billed at 8 credits per open-page hour with a 60-second minimum per page. | not published (not published) |
| Interactive control | Whatever CDP exposes, for as long as the socket is open. Concurrency is capped per plan at 20, 100 and 400 simultaneously open pages. | Interact scrapes a page then drives it with AI prompts or code (write, press, click, wait, screenshot); Agent navigates from a description; a Browser Sandbox provides managed sessions. Interact bills 2 credits per browser minute. |
| Exit geography | Every Web Data call takes proxy: auto | datacenter | residential and an ISO-3166 alpha-2 country. A CDP session additionally takes region, city, isp and a sticky session id. | A location object taking a country code and a languages array, plus three proxy modes: basic, enhanced and auto. |
| Cost of getting past a block | Datacenter egress is free. Residential egress is metered per byte at 320 credits per GB — the sidecar is sampled every 5 seconds and the session is terminated once it can no longer pay. | auto retries with enhanced proxies and bills 5 credits for that scrape when the retry succeeds; a first attempt that succeeds on basic bills only the regular cost. |
| Cache controls | scrape takes maxAge in milliseconds, defaulting to 0 — always live. A cache hit still counts as a scraped page. extract bills only uncached source pages, so iterating on a schema over pages you already fetched is free. | maxAge (default 172,800,000 ms — two days), minAge for cache-only lookups, and storeInCache. |
| Documents at a URL | The pdf format renders the page you scraped to PDF; the pipeline is a browser page runner, not a document parser. | Auto-detects and parses PDFs, DOCX and other document types from URLs. PDF parsing bills 1 credit per PDF page. |
| Client surface | REST over HTTPS, plus a remote MCP server at /mcp exposing scrape, extract, map, screenshot, brand, styleguide, fonts and crawl as tools. No first-party language SDKs. | Official SDKs for Python, Node.js, Go, Rust, Java and Elixir plus a CLI, with the repository README listing nine languages including Ruby, .NET and PHP, and an official MCP server for Cursor, Claude and Windsurf. |
| Published operating limits | Concurrency scales with the plan — 20, 100 and 400 open pages on Developer, Business and Scale. The per-endpoint request throttles are fixed in the service (scrape 60/min, map and screenshot 30/min, extract 20/min, crawl start 10/min) and do not vary by plan. | Per-plan, per-endpoint tables: /scrape from 10/min on Free to 10,000/min on Scale, /crawl from 2/min to 2,000/min, concurrency from 2 to 150+, queued jobs from 50,000 to 300,000+. Limits are shared across a team’s API keys and return HTTP 429. |
| Run it yourself | Hosted only. There is no self-host distribution. | AGPL-3.0 with a first-party self-hosting guide — but self-hosted instances do not get Fire-engine, which is where the advanced IP-block and bot-detection handling lives, and engines beyond fetch and Playwright must be configured by hand in .env. |
| Result delivery | Crawl webhooks are signed: every delivery carries X-Wayfern-Signature: sha256=<hmac> computed over <timestamp>.<body>. | Webhooks are documented for async event delivery. Screenshot outputs are returned as URLs that expire after 24 hours. |
Both bill in “credits”, and the word means something different on each side. Compare the unit being counted, then the dollars — never the credit numbers directly.
Firecrawl counts pages. Scrape, crawl and map are 1 credit per page, Monitor is 1 credit per page per check, Search is 2 credits per 10 results, and Interact is 2 credits per browser minute. Its published plans are Free at $0 (1,000 credits, 2 concurrent), Hobby at $16/month, Standard at $83/month, Growth at $333/month and Scale at $599/month, with Enterprise custom. Read those prices carefully: every paid tier on the pricing page rendered with a “Billed yearly” qualifier, and no month-to-month figure rendered at all, so they are the annually-billed monthly rates rather than what you would pay for a single month.
Wayfern counts pages *and* seconds *and* bytes, out of one balance. Web Data rates are scrape 1 credit per page, extract 1 credit per uncached source page, crawl 1 credit per successful page, map 2 credits per 10 URLs, screenshot 5, fonts 5, brand profile 10, styleguide 10, and web search 2 per provider result page fetched. Held browser time is 8 credits per open-page hour with a 60-second minimum. Residential bandwidth is 320 credits per GB metered per byte as it is consumed; datacenter egress is free.
Wayfern plans are Developer at $19/month for 1,520 credits and 20 concurrent sessions, Business at $99/month for 9,000 credits, 100 concurrent sessions and 10 seats, and Scale at $499/month for 46,000 credits, 400 concurrent sessions and 50 seats. Paying yearly takes 20% off twelve months. Credit packs — 1,000 for $12.50, 5,000 for $55, 20,000 for $200 — do not expire and roll over; the monthly grant is spent first.
The practical consequence: a fixed-shape pipeline over a known page count is easier to forecast on Firecrawl, because one page is one credit and that is the whole model. A workload whose cost is dominated by how long a browser stays open and how many residential bytes it pulls is easier to forecast on Wayfern, because those are the two things it actually meters — an idle held session bills 8 credits an hour whether it fetches one page or fifty.
Both escalate when a request is blocked. One escalation is priced as a flat surcharge on the call; the other is priced by the byte.
Firecrawl’s ladder is basic → enhanced, either chosen explicitly or left to auto. Its docs describe enhanced as the more reliable mode on certain sites, and in auto mode a successful enhanced retry bills 5 credits for that scrape while a first-attempt success on basic bills only the regular cost. You do not pay for the escalation you did not need, and you know the ceiling of the one you did.
Wayfern’s ladder is datacenter → residential, requested per call as proxy: auto (default), datacenter or residential. There is no per-retry surcharge — instead residential bytes are the billable thing, at 320 credits per GB. The per-container proxy sidecar meters real rx+tx bytes, `ResidentialMonitorService` samples it every five seconds and debits the elapsed bytes live, and a session that can no longer pay is terminated through the normal teardown path rather than being allowed to run up an unmetered bill.
Which model is kinder to you depends on page weight. A blocked scrape of a lean HTML page costs a flat surcharge on Firecrawl and almost nothing in bytes on Wayfern; a blocked scrape of an image-heavy SPA is the reverse, which is why Wayfern’s scrape blocks images and media by default and only stops doing so when you ask for a screenshot or PDF.
Stay on Firecrawl if you want the engine in your own infrastructure — AGPL-3.0 plus a self-hosting guide is a real option Wayfern does not offer at all, even with the Fire-engine caveat on self-hosted installs. Stay if your corpus is documents: it parses PDFs and DOCX straight from a URL at 1 credit per PDF page. Stay if your team writes Go, Rust, Java, Elixir, Ruby, .NET or PHP and wants a maintained SDK rather than raw REST. Stay if you need one call to return markdown, a summary, structured JSON, images, branding and a natural-language answer about the page. And stay if procurement needs the numbers up front — published per-endpoint RPM, concurrency and queue depths per tier are more than most vendors will put in writing.
Move to Wayfern if the browser has to survive between steps: logging in once and staying logged in, walking a multi-page checkout, driving a canvas or a WebSocket app, or anything you would rather write in Playwright than describe as a list of actions. Move if the exit IP has to be pinned to a city or an ISP and stay pinned for the whole session. Move if you want one balance covering held browser time, page scraping, search and residential bandwidth instead of separate line items. And move if bandwidth is your real cost centre — datacenter egress is free and residential is metered per byte rather than surcharged per retry.
The request bodies rhyme — several option names are identical — so the port is mostly mechanical. Two things do change: the response envelope, and the cache default.
Wayfern replies with `{ success, data, credits }`, where `credits` is exactly what that call debited, so you can log spend per request without a separate usage lookup. The document itself sits in `data`: `data.markdown`, `data.html`, `data.rawHtml`, `data.links`, `data.json`, `data.summary`, `data.metadata`, plus `data.cached` telling you whether the cache answered.
The cache default is the sharper difference. Firecrawl documents a maxAge default of 172,800,000 ms — two days — so an unspecified call may legitimately return two-day-old content. Wayfern defaults maxAge to 0, meaning always live. If you were relying on Firecrawl’s cache for credit savings, set maxAge explicitly on the Wayfern side or you will pay for a fresh fetch every time.
Authentication is a `wf_` API token carrying the `web` scope in an Authorization: Bearer header, or a dashboard session for the in-app console.
// Option mapping, Firecrawl -> Wayfern
// formats -> formats: markdown | html | rawHtml | links
// | screenshot | pdf | json | summary
// onlyMainContent -> onlyMainContent (same name, same default: true)
// includeTags -> includeTags (same name, CSS selectors)
// excludeTags -> excludeTags (same name, CSS selectors)
// waitFor -> waitFor (ms, max 30000) or waitForSelector
// maxAge -> maxAge (ms) — but Wayfern defaults to 0 = always live
// location.country -> country (ISO-3166 alpha-2, lower-cased)
// proxy: 'basic' -> proxy: 'datacenter'
// proxy: 'auto' -> proxy: 'auto' (datacenter, residential on a block)
// proxy: 'enhanced' -> proxy: 'residential' (always residential; metered per byte)
const res = await fetch('https://api.wayfern.com/api/v1/scrape', {
method: 'POST',
headers: {
Authorization: `Bearer ${process.env.WAYFERN_TOKEN}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({
formats: ['markdown', 'json'], // json adds +4 credits for this page
onlyMainContent: true,
excludeTags: ['nav', 'footer'],
proxy: 'auto',
country: 'de',
maxAge: 172800000, // opt back in to a 2-day cache
jsonOptions: { prompt: 'the plan names and their monthly prices' }
})
});
const { data, credits } = await res.json();
// data.markdown, data.json, data.links, data.metadata, data.cached
// credits === what this single call debited (1, or 5 with the json add-on)No. Wayfern is a hosted service; there is no self-host distribution. Firecrawl is AGPL-3.0 with a first-party self-hosting guide, so if in-house deployment is a hard requirement it is the better answer — with the caveat its own guide states, that self-hosted instances do not have access to Fire-engine, which includes the advanced handling for IP blocks and bot detection, and that engines beyond fetch and Playwright have to be configured manually in .env.
The core overlaps: both have scrape, crawl and map, and both have search. Firecrawl additionally documents Batch Scrape, Monitor, Interact and an AI Agent endpoint, and returns more formats from one call, including images, branding, product, audio, video and a natural-language query over the page. Wayfern adds four site-level reports Firecrawl’s endpoint list does not name — brand profile at 10 credits, styleguide at 10, fonts at 5 and screenshot at 5 — and exposes all of them, plus crawl, over an MCP server at /mcp.
Firecrawl publishes Interact at 2 credits per browser minute. Wayfern bills an open page at 8 credits per hour, with every page billed for at least 60 seconds. Those are two different currencies, so the credit counts are not comparable directly — value them in dollars first. Wayfern credits list at $0.0125 each and drop to $0.010 in the 20,000 pack; Firecrawl’s per-credit price depends on which of its published tiers you are on.
They price it almost identically — 1 credit per page each — so pick on operational fit rather than rate. Firecrawl publishes the ceilings that matter for a big job (queue depth from 50,000 up to 300,000+ jobs, per-plan crawl RPM, concurrency up to 150+ on Scale), which makes capacity planning straightforward. Wayfern gives higher concurrency per tier — 400 simultaneous open pages on its $499 Scale plan versus 150+ on Firecrawl’s — and signs its crawl webhooks with an HMAC over the timestamp and body, but its per-endpoint request throttles are fixed rather than scaling with the plan.
Yes, and for some teams that is the honest answer. Nothing about either product is exclusive: run bulk URL-to-markdown wherever it is cheapest for your page mix, and keep the sessions — logins, checkouts, anything that must hold one identity and one exit IP across steps — on a CDP gateway. The cost of running both is two bills and two auth flows, not a technical conflict.
Firecrawl documents a zeroDataRetention option on scrape requests, but its pricing and enterprise pages list zero data retention, SSO and advanced security only under the custom-priced Enterprise plan — none of them appear on a self-serve tier. Ask both vendors directly rather than trusting a comparison page: retention and security terms change more often than feature lists, and this page will not always be current.
Browser sessions, the Web Data API, search and captcha solving all draw on one credit balance. Start on any of them.