npx dlbrowser connect --key dlb_xxx

The 60-second try

pip install dlbrowser
dlbrowser fetch https://example.com

Every fetch tells you which backend got through and how long it took — because the engine picks the cheapest one that works and only escalates when a site fights back:

{ "success": true, "backend": "curl_cffi", "load_time": 0.03, "blocked": false }

And every run is metered against a plan, in the open — no surprise invoice:

{ "plan": "scout", "remaining_daily": 497, "remaining_monthly": 2497,
  "upgrade_url": "https://dekryptlabs.github.io/dlbrowser/pricing.html" }

That's a real response from the live gateway. Start free — 2,500 credits, no card.

Why your agent needs this

You wire web access into an agent. It works in the demo. Then it meets the real web:

• One site loads with a 50ms HTTP request. The next is an empty React shell until JS runs.
• Cloudflare and DataDome quietly serve your headless browser a challenge page.
• Your agent's built-in fetch returns "" — not an error, an empty string — and keeps going.
• You have no idea which sites failed, which backend would've worked, or what any of it cost.

DLBrowser is the capability layer that fixes this. Not a scraper. Not a crawler. Acquisition infrastructure for AI agents — reliable, observable, billable.

The engine: start cheap, escalate only when blocked

curl_cffi  →  tls_client  →  playwright  →  nodriver (CDP)  →  firecrawl
  ~50ms         ~200ms        full JS        max stealth       last resort
  HTTP-level, no browser       │            browser-level, real Chromium
                               └── auto-escalates when a block is detected

~70% of real fetches never need a browser. Starting with a 50ms request and climbing the ladder only on a detected block keeps you fast and cheap — while still getting through the sites that stop everything else. Five backends. Firecrawl has two. Crawl4AI has one.

What resets your expectations

Fewer tokens, cleaner signal

Raw HTML pours tags, scripts, and boilerplate into your agent's context — you pay tokens for noise, and the model burns attention parsing <div class> soup. DLBrowser returns clean markdown or extracted content instead.

Real measurement through the live gateway — a Wikipedia article:

~4× less context per fetch on a content page — lower API cost, more room in the window, and better signal for the model to reason over. Savings vary by page (a sparse link list saves little, and your agent picks the mode) — so measure your own:

import asyncio, tiktoken
from hermes_browser import fetch          # pip install dlbrowser
enc = tiktoken.get_encoding("cl100k_base")
raw = asyncio.run(fetch(url, mode="html"))["content"]["html"]
md  = asyncio.run(fetch(url, mode="markdown"))["content"]["markdown"]
print(len(enc.encode(raw)), "→", len(enc.encode(md)), "tokens")

One line, every host

npx dlbrowser connect --key dlb_xxx
# detects and configures: claude-code · claude-desktop · cursor · windsurf · cline · codex

Or point any MCP client at the free hosted demo gateway (try it with no local setup — some features are gated on the demo; self-host for the full engine):

claude mcp add dlbrowser --transport http \
  --url https://api.dekryptlabs.com \
  --header "Authorization: Bearer dlb_xxx"

Your agent immediately has: fetch · scrape · smart_extract · screenshot · markdown · crawl · search · serp · status · account · topup.

Can I trust it? (architecture)

Agent / CLI / Extension / MCP client
        │
   ┌────┴─────┐
   │ Gateway  │  Paywalled — 401 no key · 402 over quota · free: status/account
   └────┬─────┘
   ┌────┴─────┐
   │  Router  │  Adaptive per-domain scoring: success · latency · cost · freshness
   └────┬─────┘
   ┌────┴─────────────────────────────┐
   │  curl_cffi → tls → playwright →  │  self-healing cascade
   │  nodriver → firecrawl            │
   └────┬─────────────────────────────┘
   ┌────┴─────┐
   │  Ledger  │  per-run backend · credits · cost · trace_id (OpenTelemetry)
   └──────────┘

The router learns per-domain — more usage, better routing. Everything above the gateway is MIT and self-hostable. Read the code before you trust it; that's the point of open source.

Can it beat Cloudflare?

On many real sites, with no browser at all. We tested 5 Cloudflare-protected sites from a datacenter IP with no residential proxy (worst case):

3/5 passed on HTTP-level TLS impersonation alone. The two failures weren't fingerprint failures — they're IP-reputation blocks that need residential-proxy routing (supported, disabled in this test). No tool beats Cloudflare universally; DLBrowser's answer is layered escalation. Full methodology + "what beating Cloudflare actually means" → marketing/cloudflare.md.

We have not published broad head-to-head benchmarks vs Firecrawl/Crawl4AI yet — those are next, with the methodology published alongside. We don't print numbers we made up. Don't trust our table — run it on your own hardest sites:

pip install "dlbrowser[full]" && python3 -m playwright install chromium
dlbrowser fetch <a-url-that-blocks-your-current-tool>   # see the backend that got through

Pricing

1 credit = 1 page, any backend. Annual 20% off. Self-hosting is free forever. Full pricing → PRICING.md · hosted: dekryptlabs.github.io/dlbrowser/pricing.html

Will my company approve it?

• Multi-tenant — organizations, teams, seats, roles
• API keys — create, revoke, rotate, scope, expire (SHA-256 hashed)
• Audit logs — immutable event ledger: who did what, when, at what cost
• Webhooks — HMAC-SHA256 signed, with a dead-letter queue
• SLA monitoring — scheduled page diffing with noise-tolerant change detection
• Self-hosted — Docker one-liner, full feature parity, data stays in your network

Enterprise plans publish real prices (from $999/mo) — no "call us" black box. sales@dekryptlabs.com

When not to use DLBrowser

• You need pre-built datasets → Bright Data / Apify
• You need a visual scraping IDE → Octoparse
• You need screenshot-as-a-service → Urlbox

DLBrowser is for teams running AI agents that need reliable, observable, cost-controlled web access at scale.

Docs