hyperbrowser.ai

Hyperbrowser's Web API can return page content as Markdown, HTML, screenshots, links, or JSON that matches a schema you define. You choose the formats per request, and the same set applies whether you fetch a single page, crawl a site, or search the web. This makes it usable both for agents that read prose (Markdown) and for pipelines that need typed fields (schema-matched JSON).

The three extraction actions

The Web API covers three task types, and each accepts the same output options:

• Fetch — retrieve one page and return it in your chosen formats.
• Crawl — walk a site and collect pages, returning the same formats per page.
• Search — run a web search and return results in those formats.

Because the output contract is shared, you can switch from a single fetch to a crawl without rewriting your parsing logic.

Output formats and when to use each

The schema-matched JSON is the key option for agents: instead of handing a model a wall of Markdown and hoping it extracts the right fields, you declare the shape you want and get data back in that shape.

Requesting outputs in the SDK

You pass the desired formats in the outputs object of web.fetch. The example from Hyperbrowser's site requests Markdown and links from a single page:

await client.web.fetch({
  url: "https://example.com",
  outputs: {
    formats: ["markdown", "links"]
  }
});

The expected result is the page rendered as Markdown plus a list of its links. To get structured data instead, request a JSON format with your schema; to capture visual state, add a screenshot format. The same formats pattern applies to crawl and search calls.

Practical notes

• Pick formats deliberately. Each requested format adds processing; ask for Markdown and links when you only need text and navigation, and reserve screenshots for cases where rendering matters.
• Schema JSON is the bridge to agents. Define fields your agent or downstream system expects, then let the API do the extraction rather than parsing HTML yourself.
• Combine formats in one call. A fetch returning Markdown, links, and a screenshot gives an agent both readable content and navigational context without a second request.
• Crawls multiply output. Since formats apply per page, a crawl with screenshots enabled returns an image for every page — size your request to the job.

Hyperbrowser also offers a free starting tier with 5,000 credits, so you can test which format combination fits your extraction task before committing to a plan.

Hyperbrowser is a cloud platform that gives AI agents three things in one place: a browser to work in, isolated compute to run code on, and web data APIs to pull structured content from sites. It fits developers and teams building agents that need to log into real websites, execute code safely, or extract page data at scale. You connect through Playwright, Puppeteer, the Node.js or Python SDKs, the CLI, or MCP, and you can start with a free account that includes 5,000 credits.

The three core offerings

Cloud-hosted Chrome sessions

You control Chrome through an API rather than running it locally. Point Playwright or Puppeteer at a cloud session, and the platform handles the browser infrastructure. Sessions can keep logins between runs, and you can watch a session live while it works. The site reports startup from request to ready browser at under 500 ms, and cites 100M+ sessions run and 1,000+ concurrent isolated browsers.

This matters when your agent needs a real browser state—cookies, a logged-in profile, a page that renders with JavaScript—rather than a simple HTTP fetch.

Isolated sandboxes (microVMs)

Sandboxes are separate virtual machines where your agent can install dependencies, run commands, and expose local services without touching your application environment. You can save the environment as a snapshot and restore it in later runs, so a prepared setup doesn't have to be rebuilt each time.

A minimal SDK example from the site:

const vm = await client.sandboxes.create({
  imageName: "node",
});

await vm.exec("echo Sandbox ready");

await vm.createMemorySnapshot({
  snapshotName: "node-base",
});

The pattern is: create a sandbox from an image, run commands inside it, then snapshot the state for reuse.

Web API for fetching, crawling, and searching

The Web API fetches a page, crawls a site, or searches the web, and returns Markdown, HTML, screenshots, or JSON matching a schema you define. A fetch call can request multiple output formats at once:

await client.web.fetch({
  url: "https://example.com",
  outputs: {
    formats: ["markdown", "links"]
  }
});

This is the lighter path when you need page content rather than an interactive browser session.

Running agent tasks from a prompt

Beyond raw browser and compute access, Hyperbrowser can run browser tasks from a prompt using HyperAgent, Browser Use, or computer-use models inside a managed browser. You send a task, inspect the steps the agent took, and retrieve the result. The site's example is a flight search from Los Angeles to San Francisco on Google Flights—a task that requires navigating a real site rather than calling a clean API.

What supports production use

The platform lists several operational features that matter once you move past a prototype:

• Saved state — reuse browser profiles with cookies and logins; restore sandboxes from memory snapshots.
• Session recordings — watch sessions live and replay recordings to debug a failed run.
• Isolated execution — commands run in VMs separate from your application.
• SDKs and integrations — Playwright, Puppeteer, Node.js and Python SDKs, CLI, and MCP.
• Security and access controls — the site references encryption, access controls, and independent security assessments, with a separate security overview page.

Who it is for, and when it fits

Choose Hyperbrowser when your agent's job depends on interacting with websites as a user would—maintaining a login, clicking through a flow, or rendering dynamic pages—or when it needs to run untrusted or dependency-heavy code in isolation. The combination of browser sessions, snapshots, and replayable recordings is aimed at teams that need to debug and reproduce agent runs, not just fire one-off requests.

If you only need to pull static page content, the Web API's fetch-and-return-Markdown path is the simpler entry point. If you need full browser control, start with a Playwright or Puppeteer connection to a cloud session.

Getting started

The site offers a free account with 5,000 credits included, plus a copyable agent setup prompt and a demo booking option. A practical first step is to run one fetch through the Web API to confirm your SDK connection, then move to a browser session or sandbox depending on whether your task needs interaction or code execution. Pricing beyond the free tier is listed on the pricing page; check it there before committing to volume, since the free credits are a starting allowance rather than a usage guarantee.

Hyperbrowser starts with a free account at $0 that includes 5,000 credits, and paid tiers are listed on its pricing page. The free credits let you test browser sessions, sandboxes, and Web API calls before committing to a plan. The site does not publish per-credit rates or what each action costs in credits, so treat the pricing page as the source of truth for tiers and usage rates.

What the Free Tier Covers

The free tier is a credit allowance, not a separate product. The same platform features are available:

• Cloud Chrome sessions controlled through an API, with Playwright or Puppeteer connections
• Sandboxes (isolated microVMs) for running code, installing dependencies, and saving memory snapshots
• Web API calls that fetch pages, crawl sites, or search the web and return Markdown, HTML, screenshots, or schema-matched JSON
• AI agents such as HyperAgent, Browser Use, or computer-use models in a managed browser

With 5,000 credits, the practical question is how far that goes. Because the site does not state a credit-to-action conversion, the reliable approach is to run a small representative task first and check your credit balance afterward.

What Consumes Credits

Every billable surface on the platform is a candidate for credit usage:

The platform advertises 100M+ sessions run, 1,000+ concurrent sessions, and under 500 ms startup from request to ready browser. Those figures describe capacity, not price. Concurrency and session volume are the levers that will most affect a paid plan, so size your plan around peak parallel sessions rather than total monthly runs alone.

A Practical Way to Test the Free Tier

1. Create a free account and confirm the 5,000-credit balance.
2. Run one small task per surface — for example, a single Web API fetch of one page, one short browser session, and one sandbox command.
3. Check the credit balance after each step to see which surface consumes credits fastest.
4. Scale the test to a realistic workload, such as a crawl of a few dozen pages, and compare consumption against your expected monthly volume.
5. Use the result to pick a paid tier on the pricing page.

Expected result: you learn your own cost per task, which is more useful than a generic rate because usage patterns differ sharply between a fetch-heavy pipeline and long-running agent sessions.

Decision Factors Before Paying

• Concurrency needs: if you run many agents in parallel, the 1,000+ concurrent session capacity matters more than total credits.
• Session volume: high-volume scraping favors predictable per-request pricing; long interactive sessions favor plans priced by runtime.
• Startup requirements: the sub-500 ms startup is a platform feature, not a paid add-on, so it should not change your tier choice.
• State reuse: saved browser profiles and memory snapshots reduce repeated setup work, which can lower effective usage.

Common Pitfalls

• Assuming the free tier is unlimited because the account costs $0 — it is a 5,000-credit allowance.
• Estimating cost from the marketing metrics (100M+ sessions, 1,000+ concurrency) instead of from your own test runs.
• Forgetting that sandbox snapshots and agent tasks may consume credits differently from simple fetches.

For exact tier names, prices, and credit rates, check the pricing page at hyperbrowser.ai/pricing, since those details are not included in the available site information.

Hyperbrowser sandboxes let you run code in isolated virtual machines that are separate from your main application, and memory snapshots let you save a configured environment so later runs can restore it instead of rebuilding it. Use them when an agent or workflow needs to install dependencies, execute commands, or expose local services without touching your production environment. The Node.js SDK covers the full loop: create a sandbox, run commands, and save a snapshot for reuse.

What a sandbox is for

A sandbox is an isolated VM you control through the Hyperbrowser SDK. Hyperbrowser describes the purpose directly: run commands in isolated virtual machines, separate from your application. That separation matters when agent-generated code is unpredictable — a failed install or a runaway process stays inside the sandbox.

The documented capabilities are:

• Install dependencies — set up packages the task needs before running it.
• Execute commands — run shell commands inside the VM and read the output.
• Expose local services — make a service running inside the sandbox reachable, so a browser session or agent can interact with it.

Creating a sandbox and running a command

The site's example uses the Node.js SDK. You specify an image name, execute a command, then snapshot the result:

const vm = await client.sandboxes.create({
  imageName: "node",
});

await vm.exec("echo Sandbox ready");

await vm.createMemorySnapshot({
  snapshotName: "node-base",
});

What happens at each step:

1. Input: an image name ("node" in the example) selects the base environment.
2. Action: sandboxes.create provisions the isolated VM.
3. Expected result: a sandbox object you can call exec on.
4. Action: vm.exec runs a command inside the VM and returns its output — the example expects Sandbox ready.
5. Action: createMemorySnapshot saves the environment under a name you choose.

How memory snapshots work

A memory snapshot captures the state of a sandbox environment so you can restore it in a later run. The practical effect is that expensive setup — dependency installs, configuration, service startup — happens once, and subsequent runs start from the saved state.

Two things to keep in mind when planning around snapshots:

• Name them meaningfully. The snapshot name ("node-base" above) is how you identify the environment to restore later, so pick names that describe the stack, not the run.
• Snapshot after verification. Take the snapshot once exec confirms the environment is in the state you want; a snapshot of a half-installed environment just reproduces the problem.

The site also notes that sandbox environments can be restored from memory snapshots, and separately that browser profiles can be reused with saved cookies and logins — the two are distinct: snapshots cover the compute environment, saved browser state covers sessions.

Choosing between sandboxes and browser sessions

Both are part of the same platform, but they solve different problems:

A common pattern combines them: a sandbox hosts a service or script, and a browser session connects to it or to the web. The site's own framing is "browsers, compute, and web data" as three connected pieces.

Getting started and what to check

Hyperbrowser lists a free tier: $0 to start with 5,000 credits included. The site does not publish per-sandbox pricing details on the pages referenced here, so check the pricing page before committing to heavy snapshot or concurrency use.

Before building on sandboxes, confirm:

• SDK access — the examples use the Node.js SDK; the site also lists Python SDK, CLI, and MCP integrations.
• Image availability — the example uses a node image; verify the image you need is offered.
• Debugging path — session recordings and live inspection are described for browser sessions; use them to watch agent runs when a sandbox task fails.

If your task is "run this agent's code somewhere safe and don't pay the setup cost every time," a sandbox plus a named memory snapshot is the direct fit.

Hyperbrowser hosts Chrome sessions in the cloud and exposes them through an API, so you connect Playwright or Puppeteer the same way you would connect to any remote browser: create a session, get its connection endpoint, and point your existing automation library at it instead of launching a local browser. This works for teams that already have Playwright or Puppeteer scripts and want managed browsers, saved logins between runs, and live session inspection without changing their automation code.

What Hyperbrowser provides for the connection

Hyperbrowser describes itself as a gateway for AI agents to the internet, offering cloud Chrome sessions, isolated sandboxes, and web data APIs. The relevant capabilities for this task:

The site also cites 100M+ sessions run and 1,000+ concurrent isolated browsers, which matters if you plan to scale parallel runs.

Prerequisites

• A Hyperbrowser account and API key. The pricing page lists a free tier: $0 to start with 5,000 credits included.
• A working Playwright or Puppeteer script that currently launches a local browser.
• Node.js or Python, depending on which SDK you use.

General connection pattern

The exact method names come from the Hyperbrowser SDK documentation; the site shows SDK usage in its examples (for instance, client.sandboxes.create(...) and client.web.fetch(...)). The connection flow follows the standard remote-browser pattern:

1. Create a session through the Hyperbrowser API or SDK. The response includes a connection endpoint (typically a WebSocket URL) for that session.
2. Replace the local launch call in your script with a connect call that uses that endpoint. In Playwright this is chromium.connectOverCDP(...) or chromium.connect(...); in Puppeteer it is puppeteer.connect({ browserWSEndpoint: ... }).
3. Run your existing automation against the returned browser object. Your page interactions, selectors, and assertions stay the same.
4. Close the session when done so the browser is released.

Expected result: your script runs against a cloud-hosted Chrome instance, and you can watch the session live from the Hyperbrowser dashboard.

Playwright sketch

// Pseudocode: confirm exact SDK method names in Hyperbrowser docs
const session = await hyperbrowser.sessions.create(); // returns a connection URL
const browser = await chromium.connectOverCDP(session.wsEndpoint);
const page = await browser.newPage();
await page.goto("https://example.com");
// ...your existing automation...
await browser.close();

Puppeteer sketch

const session = await hyperbrowser.sessions.create();
const browser = await puppeteer.connect({ browserWSEndpoint: session.wsEndpoint });
const page = await browser.newPage();
await page.goto("https://example.com");
await browser.close();

Treat the method names above as placeholders. The site confirms Playwright and Puppeteer connectivity but does not publish the exact session-creation signature in the material available here, so check the SDK reference before running.

Persisting logins between runs

By default, a new session starts clean. To keep cookies and logins, use saved browser profiles: create or attach a profile to the session so state carries over to later runs. This is the main reason to use a managed browser instead of a fresh local instance for recurring tasks like checking a dashboard behind a login.

Practical pattern:

• First run: log in manually or via script, then let the profile save.
• Later runs: attach the same profile and skip the login step.
• Keep separate profiles per account or environment to avoid state collisions.

Debugging a run

Two features help when a script fails in the cloud but worked locally:

• Live inspection: watch the session in real time to see what the page actually shows.
• Session recordings: replay a finished run to find the step where it diverged.

For flaky selectors or timing issues, replay is usually faster than adding logging and re-running.

Common snags

• Connecting instead of launching: if your script still calls chromium.launch() or puppeteer.launch(), it runs locally and never touches Hyperbrowser. Swap in the connect call.
• Closing too early: closing the browser object ends the session; make sure all async work finishes first.
• Assuming state persists: without a saved profile, each session starts fresh, so logins won't carry over.
• Endpoint format: Playwright's CDP connect and Puppeteer's WebSocket connect expect different endpoint styles; use the one your library documents.

When this setup fits

Choose the cloud-session approach when you need parallel isolated browsers, persistent logins, or replayable debugging for agent-driven automation. If you only run a single short script occasionally on your own machine, a local browser is simpler and avoids the session-management step.