Browser Use's Fetch Use Beats Anti-Bot Systems at 81% Success Rate

Web scraping has always been a game of cat and mouse. You write a clean Python script using requests, point it at a target URL, and half the time you get back a bot-detection wall instead of the data you wanted. Browser Use just launched Fetch Use, a Python SDK that replaces your plain HTTP calls with requests that look like they came from a real Chrome browser, complete with stealth, proxy rotation, and session management baked in.

The pitch is simple: one function call, any website, no getting blocked. But there is more going on under the hood than a thin wrapper around a headless browser.

The Problem Every Scraper Hits

Traditional tools like BeautifulSoup, requests, and Playwright require you to write a custom script for each page you want to scrape. You inspect the HTML and write parsing logic specific to that page's structure. This is fragile. Every site needs a new script, and sites change regularly, which means maintaining scripts.

In 2018, roughly a third of web pages required JavaScript execution to render meaningful content. In 2026, that number is over 70%. React, Next.js, Vue, Nuxt, Angular, Remix, Astro -- the modern web is built on frameworks that render content client-side, often after multiple API calls, lazy loading events, and framework hydration cycles. The result is that a plain requests.get() call increasingly returns an empty shell instead of the data you need.

And even when you solve the rendering problem with a headless browser, you still face the stealth problem. Anti-bot systems like Cloudflare, Akamai, PerimeterX, and DataDome inspect browser fingerprints, IP reputation, and behavioral signals. Running Playwright out of the box does not fool them.

What Fetch Use Actually Does

fetch-use is a Python SDK for getting content from websites the way a real browser would. This matters because the webpage you see is often not the same page your scraper sees -- a site might send different HTML, redirect you, or block the request entirely.

When you call fetch-use, your script sends a request to Browser Use. Browser Use fetches the URL in a way that looks much closer to a real browser than a normal Python script, handles details like redirects, cookies, sessions, and response formatting, and then returns the response to your Python program.

The stealth layer is Browser Use's custom Chromium fork. According to their own stealth benchmark across 71 websites with Cloudflare, Akamai, PerimeterX, DataDome, and other anti-bot vendors, Browser Use has the best stealth success rate at 81%, nearly double Browserbase's 42%. That infrastructure is what fetch-use routes through.

Getting Started in Three Lines

Installation is a standard pip install, and usage mirrors Python's familiar requests API:

pip install fetch-use
export BROWSER_USE_API_KEY=bu_your_api_key

from fetch_use import fetch_sync
response = fetch_sync("https://example.com", output_format="markdown")
print(response.text)

The response object returns status_code, headers, text, and a .json() method -- the same interface you already know. The key addition is the output_format parameter, which controls how the page content comes back to you.

Three Output Modes Worth Knowing

This is where fetch-use goes beyond a simple proxy. Raw HTML is usually noisy. A page might include navigation, scripts, styles, footers, tracking tags, layout markup, and other content that has nothing to do with the data you actually want. For articles, docs, product descriptions, and other text-heavy pages, output_format="markdown" is often easier to work with.

• markdown -- strips nav, scripts, and layout noise; returns clean readable text. Best for articles, docs, and LLM pipelines.
• structured -- returns a JSON object with the page's title, links, headings, forms, and tables. Useful for exploring a new page before writing a parser.
• raw HTML -- the default; full rendered DOM for when you need to run your own parsing logic.

There is also session support, which is more useful than it sounds. Some sites only make sense across multiple requests. The first page sets cookies, the second page expects them, and the third page changes depending on what happened before. You pass a session_id string and all requests sharing that ID carry the same cookies automatically.

from fetch_use import fetch_sync
session_id = "products-run-1"
home = fetch_sync("https://example.com", session_id=session_id)
products = fetch_sync("https://example.com/products", session_id=session_id, output_format="markdown")
print(products.text)

When to Use It, and When Not To

Fetch Use sits in a specific lane. fetch-use is best when you want page content without opening a full browser. It handles the stealth and rendering layers, but it does not interact with pages. If your target requires clicking, scrolling, filling forms, or completing a login flow, you need a full browser agent.

The practical decision tree looks like this:

• Static public page, no anti-bot -- plain requests still works and is free
• Protected site, needs stealth, no interaction -- this is Fetch Use's sweet spot
• Needs clicks, forms, login, or JS-triggered content -- use Browser Use's full agent with browser_use.Agent
• Bulk LLM ingestion from unprotected sites -- Firecrawl at ~$0.001/scrape is cheaper

The comparison that matters most is against Bright Data's Web Unlocker, which is the closest competitor for stealth-first scraping. Bright Data gets through protected sites, but tasks can take 12 seconds to complete and cost around $0.003 per basic scrape. Fetch Use routes through the same stealth infrastructure that Browser Use uses for its full agent product.

Pricing

Browser Use offers a free tier with no credit card required. Paid plans start at $29/month for the Dev tier, scaling to $299/month for Business and $999/month for Scaleup. Browser sessions are billed at $0.02 per hour, and proxy bandwidth at $5 per GB. The free tier gives you 3 concurrent sessions to start experimenting.

Fetch Use is available now via pip install fetch-use. You will need a Browser Use Cloud API key, which you can generate for free. The broader Browser Use ecosystem -- including the open-source agent library with over 83,000 GitHub stars -- sits alongside it for when your scraping tasks need actual browser interaction. For teams already using Browser Use for agents, Fetch Use is a natural lighter-weight option for the simpler fetches in the same pipeline.