Company

Introducing Fetch: the simplest way to read the web

Harsehaj DhamiGrowth Engineer

March 11, 2026

4 min read

Copy linkIntroducing Fetch: the simplest way to read the web

TL;DR: We launched a Fetch API for Browserbase. Give us a URL and we return the page content with no browser session required. It’s fast, cheap, (~$1 / 1k pages), and perfect for agents that just need to read the web.

Browserbase was built to help AI agents automate the web. It lets developers run browsers in the cloud to click buttons, fill forms, navigate applications, and automate complex workflows. But over time we noticed something interesting: many developers were spinning up full browser sessions just to read the contents of a page.

They weren’t interacting with the site and they didn’t need to click anything or run automation. They just wanted to see what was on the page.

Sure, launching a browser for this works, but it’s not the right primitive. Spinning up a full browser session to retrieve a page is a bit like killing a mosquito with a rocket launcher. It solves the problem, but it introduces unnecessary latency, cost, and complexity.

So we built the primitive that was missing: Fetch.

Copy linkReading the web is often the first step

Agents frequently need to gather information from the web before they take action. They read documentation, inspect GitHub repositories, analyze product pages, and gather context before deciding what to do next.

If you’ve used tools like Claude Code, you’ve already seen this pattern. Before executing complex actions, the model often fetches the contents of a page to understand what’s there. It’s the fastest way to make sense of the internet.

Until now, doing this with Browserbase required launching a browser session. That meant additional infrastructure overhead even in cases where the task was simply retrieving the page content.

The Fetch API solves this by letting you retrieve web content (both html and image) directly from Browserbase infrastructure without creating a browser session.

Copy linkFetch a page with one request

The Browserbase Fetch API is intentionally simple. You provide a URL, and the API returns the page content.


curl -X POST https://api.browserbase.com/v1/fetch \
  --header 'x-bb-api-key: $BROWSERBASE_API_KEY' \
  -H "Content-Type: application/json" \
  -d '{ 
    "url": "https://httpbin.org/get"
  }'<custom-cta text="" button_text="" button_link=""></custom-cta>

The response:


{
   "status_code":200,
   "headers":{
      "Age":"6449",
      "Allow":"GET, HEAD",
      "Content-Encoding":"gzip",
      "Content-Type":"text/html",
      "Server":"cloudflare",
      "Vary":"Accept-Encoding"
   },
   "content":"<!doctype html>...",
   "content_type":"text/html",
   "encoding":"utf-8",
   "id":"f47ac10b-58cc-4372-a567-0e02b2c3d479"
}

That’s the entire API. :)

Copy linkFetching pages reliably is harder than it sounds

At first glance, fetching a page might seem trivial. After all, tools like curl have existed for decades. But modern websites introduce complications that make reliable page retrieval more difficult than it appears. Redirects, inconsistent encodings, unusual headers,all make it harder to consistently retrieve the real content of a page.

Our goal with the Browserbase Fetch API is simply, always return the page content.

The API supports a few optional parameters such as output formatting and timeouts, but the main priority is making sure developers can depend on it to retrieve the page they requested. We’ve prioritized reliability over a catalogue of shiny features.

Copy linkFetch before you browse

Fetch becomes particularly powerful when used alongside browser automation.

Many agent workflows follow a pattern like this: search → fetch → decide → browse .

An agent first searches for relevant pages. It then fetches their contents to determine whether the page is useful. Only when deeper interaction is necessary does it launch a browser.

This approach significantly reduces both latency and cost. Most pages don’t really require full browser automation. They simply need to be read.

Copy linkMaking Browserbase workflows cheaper

Running browsers is expensive infrastructure. Fetching pages is much lighter.

Because of that, we’ve just made Browserbase 10x cheaper, pricing the Fetch API at $1 per 1,000 pages. This allows agents to inspect far more of the web before deciding where to spend browser resources.

In practice, this makes many Browserbase workflows dramatically cheaper while also improving performance. Win-win!

Copy linkThe web is still the biggest API

The open web contains more data, workflows, and knowledge than any single API ever will. Documentation, research, software, and marketplaces all live there. Agents should be able to use that information easily.

Fetching a page is often the first step in doing so, and now the Browserbase Fetch API makes that step simple.

The Browserbase Fetch API is available today. Give it a URL, and we’ll return the page.

Learn more: https://docs.browserbase.com/features/fetch

Introducing Fetch: the simplest way to read the web

Share