Self-hosted Firecrawl alternatives for a VPS
Draco, Hound and self hosted Firecrawl compared on RAM, headless browser needs and API compatibility, with a pinned install and an MCP connection.
What a self-hosted Firecrawl alternative must do
A self-hosted Firecrawl alternative has one job: take a URL and hand back the page as clean markdown an agent can read. The hosted APIs charge per page, so the bill grows with how curious your agent is, and a VPS you already pay for can do the same work. The projects split on one question: does a headless browser (a real browser engine running with no window) have to start on your box?
That answer decides the memory footprint, the cost of each page, and which pages come back empty. This guide compares Draco, Hound and the self-hosted Firecrawl release, installs the lightest one at a pinned version, and wires it to an agent over MCP (model context protocol).
The four projects, and what each one actually is
Draco is one binary, written in Rust, licensed MIT or Apache-2.0. draco scrape <url> prints markdown to stdout. draco serve runs a daemon that answers on 127.0.0.1:3002, the port Firecrawl uses. As documented on 12 October 2026, it ships no container image and starts no browser by default. As of 12 October 2026 its upstream repository at github.com/0xchasercat/draco, the account behind it and its release downloads all return 404 Not Found. As of that check, a public fork still carried the source and tags up to v0.24.0 but published no release builds, so read the install section below before you plan around it.
Firecrawl self-hosted is the engine behind the hosted product, under AGPL-3.0. Its docker-compose.yaml defines seven services: playwright-service, api, redis, rabbitmq, nuq-postgres, foundationdb and foundationdb-init. You get the real crawl queue, at the price of running a small distributed system.
Hound lives in the master-fetch repository and ships to PyPI as hound-mcp, MIT licensed, version 13.2.0 (published 26 August 2026) as of 12 October 2026. It needs Python 3.11 or newer. It is an MCP server first and a fetcher second: it tries plain HTTP and escalates to a Patchright browser when the plain fetch comes back blocked or serves a JavaScript shell; its browser-enabled setup warms a browser at startup.
Trawl is here because people meet it while searching for the others, and it does a different job. It solves JavaScript challenges and CAPTCHAs with a fingerprint-patched Firefox, as a replacement for FlareSolverr in an *arr media stack. It now also reads Markdown and extracts structured JSON over MCP. The section on etiquette below explains why its challenge-solving role decides whether it belongs in your agent stack at all.
Why the browser pool is where small VPS boxes die
Each open browser tab is a separate renderer process holding its own DOM (document object model) and its own JavaScript heap. Memory therefore scales with pages open at the same moment, not with pages fetched per day. Two of these projects write that cost into their own compose files.
The data behind this chart
[
{
"label": "Firecrawl api",
"memory_limit_gb": 8
},
{
"label": "Firecrawl playwright",
"memory_limit_gb": 4
},
{
"label": "Hound (browser included)",
"memory_limit_gb": 3
}
]The Firecrawl compose file caps its api container at 8 GB and its Playwright container at 4 GB, with matching swap limits. Hound's compose sets 3 GB for one container that carries a bundled Chromium. These are ceilings the projects chose, published figures rather than measurements of a quiet system, and Redis, RabbitMQ, PostgreSQL and FoundationDB still want their share on top of the Firecrawl numbers.
A ceiling above the RAM you own does not reserve that memory. When the box runs out, the kernel out-of-memory killer ends a process, so a container vanishes from docker compose ps with no error written in the application log. Firecrawl's supplied Compose file sets no automatic restart policy, so an OOM-terminated container stays stopped; docker compose ps --all includes stopped containers. Read dmesg -T | tail after an unexplained stop. Firecrawl publishes no verified minimum host size for this stack, so size the box around your workload. Setting the numbers per service is covered in memory limits in Docker Compose.
One more browser detail costs people an evening. Docker gives a container 64 MB of shared memory at /dev/shm, but Firecrawl's Playwright service launches Chromium with --disable-dev-shm-usage, which avoids that small partition for these shared-memory files. Hound's compose raises it with shm_size: "1gb"; its dynamic browser tier inherits --disable-dev-shm-usage from Playwright through Patchright, and neither Patchright's switch removals nor Hound's ignore_default_args list removes it. Firecrawl's compose sets no shm_size at all: its playwright-service block sets CPU and memory limits and a 1 GB tmpfs at /tmp/.cache, so that container keeps the 64 MB default. Check the Chromium launch flags before copying Hound's line into an image you build around Playwright.
Extraction quality on JavaScript-heavy pages
On static HTML, a server-rendered blog, a documentation page, a news article, all of these return near-identical markdown and the fastest one wins. The difference appears on client-rendered pages, where the delivered HTML is an empty shell and the text arrives from JavaScript after load.
Draco escalates in tiers. Tier 0 and tier 1 parse the HTML with no JavaScript at all. Tier 2 runs the page's own JavaScript inside an in-process V8 isolate, which is the JavaScript engine without a browser around it, and the README states page code gets no host capability bindings there. That covers many single-page applications for a fraction of a browser's memory. When Draco meets a wall it cannot pass, draco scrape exits with code 3, needs_browser. Check it in scripts, because an empty file with a zero exit code is the failure that poisons an agent's context quietly:
draco scrape https://example.com > page.md
echo "exit=$?"Firecrawl's playwright-service drives a real Chromium, so it renders what a browser renders. The self-hosted build is still not the hosted product: the documentation states that Fire-engine, which carries the cloud service's advanced anti-bot behavior, is not included, that screenshots and page actions are not available in the default stack, and for Agent, Browser and interact it points you to Firecrawl Cloud. Hound sits in between on purpose. It fetches over HTTP and escalates per request, and its warm browser closes after an idle timeout, so a quiet box stays near baseline.
Install Draco with a pinned version
The README documented a one-line installer. Read what it does before piping it to a shell: as documented on 12 October 2026, it installs to $HOME/.draco/bin/draco, it always takes the latest release, and it checks no signature or hash. On a server, pin the version and verify the download. The v0.20.5 instructions below retain the setup checked on 12 October 2026; the pinned version's upstream documentation is unavailable for rechecking.
As of 12 October 2026 the project's release downloads return 404 Not Found, because the upstream repository no longer answers, and the get.draco.sh installer domain the project's site advertises does not resolve. There is no live release URL to fetch from, so the commands below start on a box where you already hold the v0.20.5 archive, draco-linux-x86-64.tar.gz, and its SHA256SUMS in /tmp, kept from an earlier download or copied from a machine you trust. Do not fill the gap with a mirror you have not vetted: a checksum file served from the same mirror proves nothing about the binary.
cd /tmp
sha256sum --ignore-missing -c SHA256SUMSThat prints draco-linux-x86-64.tar.gz: OK. A FAILED line means the bytes you hold are not the bytes the project published, so delete them and start again.
mkdir -p draco-v0.20.5
tar -xzf draco-linux-x86-64.tar.gz -C draco-v0.20.5
sudo install -m 755 "$(find draco-v0.20.5 -type f -name draco | head -n1)" /usr/local/bin/draco
draco scrape https://example.comThe last command prints the example page as markdown. The find is not decoration: the archive layout is not part of the project's public contract, and the official installer last checked on 12 October 2026 locates the binary the same way.
Run the daemon under its own account instead of your login user. Write /etc/systemd/system/draco.service:
[Unit]
Description=Draco fetch daemon
After=network-online.target
Wants=network-online.target
[Service]
User=draco
ExecStart=/usr/local/bin/draco serve --host 127.0.0.1 --port 3002 --max-concurrency 4
Restart=on-failure
NoNewPrivileges=true
ProtectSystem=strict
ProtectHome=true
PrivateTmp=true
[Install]
WantedBy=multi-user.targetsudo useradd --system --no-create-home --shell /usr/sbin/nologin draco
sudo systemctl daemon-reload
sudo systemctl enable --now draco
curl -s http://127.0.0.1:3002/health/health answers as soon as the daemon is listening. Connection refused means it is not, so read journalctl -u draco -n 50. The usual cause is another process already holding 3002, since that is also Firecrawl's default port. --port moves Draco. Self-hosted Firecrawl has no such flag: its port comes from the PORT variable in its Compose file, published as "${PORT:-3002}:${INTERNAL_PORT:-3002}", so change the published port there and keep every client consistent with it. Unit files in more depth: systemd service units and timers.
Now fetch the way your agent will:
curl -X POST http://127.0.0.1:3002/v1/scrape \
-H 'content-type: application/json' \
-d '{"url": "https://example.com", "formats": ["markdown"]}'Keep the fetch daemon off the public internet
A fetch API with no authentication is an open proxy. Anyone who can reach the port makes your server request any URL under your IP address, and the abuse report goes to your provider, not to them. Draco's serve flags documented on 12 October 2026 included no API key, so the protection has to be the network. Keep the default 127.0.0.1 bind when the agent runs on the same box. When the agent is elsewhere, put both ends on a private tunnel, a WireGuard VPN you host yourself is the usual answer, and bind to the tunnel address rather than 0.0.0.0. Then check from another machine that the public IP answers nothing. ufw firewall basics and least privilege user accounts cover the two halves of that.
Will your agent code change? API compatibility in practice
Draco answers the Firecrawl v1 routes: /v1/scrape, /v1/map, /v1/crawl, /v1/batch/scrape and /v1/search, and its README last checked on 12 October 2026 states that unknown fields are accepted and ignored. Compatibility depends on the requested features: Draco's official site states that screenshots and clicks return HTTP 422, so a Firecrawl v1 client requesting unsupported page actions needs request changes as well as a new base URL. Watch what moved on the other side: Firecrawl's own self-hosting guide now smoke-tests with a POST to /v2/scrape, and current SDKs speak v2 by default, while Draco's site lists v1 routes. Test each call with curl before you edit agent code, and read the JSON body rather than the status code, because field names are where these implementations drift apart.
Robots.txt, rate limits, and the line to stay behind
Draco reads robots.txt by default, and its README last checked on 12 October 2026 documents --ignore-robots to turn that off. Firecrawl documents the same default. Leave both alone. Hound checks robots.txt only when respect_robots=True is passed to smart_fetch, so enable it there. Then set your own pace: as documented on 12 October 2026, Draco's --delay puts milliseconds between requests and --max-concurrency bounds parallel jobs, with 8 as the daemon default. Two to four is kinder on a shared VPS link and rarely slower overall, because a site that starts rate limiting you costs more minutes than the concurrency saved. Cache what you fetch, so a second agent run costs the source nothing. That is also the cheapest line item in controlling what an AI agent costs you.
Challenge walls are a separate subject, and Trawl is built for exactly that: Cloudflare Turnstile, reCAPTCHA, hCaptcha and GeeTest. A challenge wall is a site refusing automated traffic in plain terms. Working around it puts you against the site's terms of use, and in some places against the law, so this guide covers fetching infrastructure and stops there. The same techniques that pass a wall are the ones site owners watch for and block, which makes any pipeline built on them fragile as well as rude. When a source matters that much, look for its RSS feed, its public API, or a bulk export. Each is cheaper to run and none of them breaks the week the wall changes.
Wire it to an agent over MCP
MCP (model context protocol) is the interface an agent uses to call a tool. Which tools reach the model at all, and whether it is allowed to call one without asking you first, is decided a level up by the harness the model runs inside, so getting the daemon listening is only half of the wiring. Draco carries an MCP server in the same binary, over stdio:
{ "mcpServers": { "draco": { "command": "draco", "args": ["mcp"] } } }The README last checked on 12 October 2026 lists draco_scrape, draco_discover and draco_search for stdio; the draco_interact_* set belongs to the daemon's HTTP MCP endpoint. Stdio only works when the agent process and the binary sit on the same machine, because the transport is that process's standard input. For an agent on another host, Hound serves MCP over HTTP instead: hound --http --host 127.0.0.1 --port 8765 publishes an endpoint at http://127.0.0.1:8765/mcp, which you reach across the tunnel. Transport choices and what to expose are in running MCP servers on a VPS.
Fetching pairs with search. An agent that can only fetch waits for you to supply URLs. Add a self-hosted SearXNG search instance and it can find them itself, the same shape as the browser search skill built on SearXNG. Once the daemon is up, it is one shared service for whichever of the self-hosted AI agents you run. If the agent side is the part you are least sure of, writing a small agent loop by hand first makes it obvious where a fetch tool plugs in and what the model does with the markdown it gets back.
FAQ
Do I need a headless browser to fetch pages for an AI agent?
Not for most pages. Server-rendered documentation, blogs and news articles come back complete from a plain HTTP fetch plus an HTML-to-markdown step, which is what Draco does in its lower tiers at roughly a browser-free 300 ms per page by the project's own figures. A browser earns its memory on client-rendered applications, where the delivered HTML is an empty shell. Draco's V8 isolate covers much of that middle ground with no browser process, and it exits with code 3, needs_browser, when it cannot.
How much RAM does self-hosted Firecrawl need on a VPS?
Its compose file sets a 8 GB ceiling on the api container and 4 GB on the Playwright container, and the same stack also starts Redis, RabbitMQ, PostgreSQL and FoundationDB. Firecrawl publishes no verified minimum host size for this stack. Under memory pressure, the kernel out-of-memory killer ends processes; if a container stops, the supplied Compose file does not automatically restart it. Check docker compose ps --all for stopped containers and confirm an OOM event with dmesg -T | tail.
Is Draco a drop-in replacement for the Firecrawl API?
For the v1 endpoints it is close. It serves /v1/scrape, /v1/map, /v1/crawl, /v1/batch/scrape and /v1/search, but compatibility depends on the requested features: screenshots and clicks return HTTP 422, so clients requesting unsupported page actions need request changes as well as a new base URL. Firecrawl's current SDKs use v2 by default, while Draco's site lists v1 routes. Verify each call your agent makes with curl first.
Does self-hosting a scraper mean I can ignore robots.txt?
No. Where the code runs changes nothing about what a site published or what its terms permit. Both Draco and Firecrawl respect robots.txt by default, and the override flag exists for sites you own or have written permission to crawl. Rate limits are enforced at the far end regardless, so a polite --delay with low concurrency keeps your IP address working. A stack that only functions by defeating a challenge wall is a stack that breaks without warning.