Remote browsers for AI agents

Give your agent
a real browser.

Start an isolated Chromium browser, control it with Playwright, or open the same session for a person to see and use. Buy a session only when your agent needs one.

  • No account or API key
  • $0.01 per five minutes
  • Live view included
  • Verifiable runtime proof

Simple prepaid pricing: sessions come in five-minute blocks. Each extension buys another block, and unused time is not refunded.

Security you can check: every public pay-per-use session lets your agent request a fresh proof of the protected runtime and approved browser software before it trusts the browser.

agent-session.log

LIVE
NEW BROWSER
SESSION ACTIVEBrowser ready

Paid block · 05:00 remaining

Agent controlPlaywrightHuman viewSame browserRuntime proofAvailableTask isolationDedicated session
PAY PER USE$0.01 / 5 min
ONE TASK · ONE BROWSER
$0.01one five-minute block
No signupfor self-serve access
Playwrightagent control
Live viewhuman control

What Popcorn is

Browser infrastructure
your agent never has to operate.

Popcorn keeps a fleet of browsers ready, gives each task its own session, routes the connection, and removes the browser afterward. Your agent simply asks for one and starts working.

YOUR CODE
A

Your agent

Requests a browser and controls it with familiar automation tools.

ORCHESTRATION

Popcorn

Launches, isolates, connects, extends, and cleans up the browser.

THE OPEN WEB
WWW

Real websites

Run in a visible Chromium browser with an optional human view.

START NOW

Self-serve, pay per use

No signup. The agent pays for a short browser session from its own wallet and receives connection links immediately.

  • $0.01 per five minutes
  • Playwright and live view
  • Fresh runtime proof
View the quickstart

LARGER INTEGRATIONS

Managed around your requirements

Keep the same verifiable browser security while adding the capacity, regions, networking, and support your agents need.

  • Dedicated browser capacity
  • Private networking and regions
  • Managed access and support
Plan a dedicated deployment

RUN IT YOURSELF

Open source and self-hosted

Deploy the browser fleet in your own cloud, choose the isolation model, and operate it with the published source and documentation.

  • Your cloud and network
  • Optional protected hardware
  • Open deployment charts
Explore the repository

The complete flow

Ask. Pay. Verify. Connect.

01

Ask for a browser

Your agent sends one request. Popcorn replies with the price and payment instructions.

02

Pay from the agent’s wallet

The wallet checks the terms, signs a one-time payment, and repeats the same request.

03

Verify the browser

Request a fresh runtime proof and check the protected environment and approved software before sharing sensitive data.

04

Connect, extend, or discard

Use Playwright or the live view, buy another five-minute block if needed, then end the browser when the task is complete.

Developer quickstart

Connect your first agent.

The public endpoint uses an automatic web-payment standard called x402. Your agent receives a price, signs payment in its wallet, and gets a browser—without creating an account.

  1. INSTALL
    Add the payment client and Playwright

    Use the verified package versions shown in the full example.

  2. LIMITS
    Set a strict payment policy

    Pin the network, token, receiver, and maximum price before the wallet can sign.

  3. TRUST
    Verify the returned runtime

    Request a fresh proof and check it against the policy your agent trusts.

  4. OPEN
    Use the returned connection

    Give the Playwright link only to the process that owns the session.

Before you start: Node.js 20 or Bun, an EVM wallet funded with Base USDC, and the small amount of network gas required by the wallet.

one paid browser · request/response
POST /v1/x402/sessions
→ 402 PAYMENT-REQUIRED

validate network, token, receiver, and price
sign the exact offer in the agent wallet
repeat POST with PAYMENT-SIGNATURE

→ 200 OK
{
  "connectUrl": "wss://gateway/…",
  "liveViewUrl": "https://gateway/…",
  "expiresAt": "2026-08-05T12:05:00Z"
}

const browser = await chromium.connectOverCDP(
  session.connectUrl
);
console.log("Human view:", session.liveViewUrl);
Open the full TypeScript implementation
INSTALLnpm install mppx@0.8.15 viem@2.55.10 playwright
agent.ts · minimal first session
import { Fetch, evm } from "mppx/client";
import type { Hex } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { chromium } from "playwright";

function required(name: string): string {
  const value = process.env[name]?.trim();
  if (!value) throw new Error(name + " is required");
  return value;
}

const endpoint =
  "https://app.popcorn.reclaimprotocol.org/v1/x402/sessions";
const expected = {
  network: "eip155:8453",
  chainId: 8453,
  asset: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" as Hex,
  payTo: "0x28f26a191D6bCa1FfD129261E726033188d65138" as Hex,
  amount: "10000"
};

const account = privateKeyToAccount(
  required("PAYER_PRIVATE_KEY") as Hex
);

const paidFetch = Fetch.from({
  methods: [evm.charge({
    account,
    authorization: { name: "USD Coin", version: "2" },
    currencies: [expected.asset],
    decimals: 6,
    maxAtomicAmount: expected.amount,
    networks: [expected.chainId]
  })],
  onChallenge: async (challenge, { createCredential }) => {
    const offer = challenge.request as Record<string, unknown>;
    if (offer.network !== expected.network ||
        String(offer.asset).toLowerCase() !== expected.asset.toLowerCase() ||
        String(offer.payTo).toLowerCase() !== expected.payTo.toLowerCase() ||
        offer.amount !== expected.amount) {
      throw new Error("Untrusted payment offer");
    }
    return await createCredential();
  }
});

const response = await paidFetch(endpoint, {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "Idempotency-Key": crypto.randomUUID()
  },
  body: "{}"
});
if (!response.ok) throw new Error("Request failed: " + response.status);

const session = await response.json();
const browser = await chromium.connectOverCDP(session.connectUrl);
console.log("Human view:", session.liveViewUrl);

This minimal example validates the current payment terms and opens one session. Before production, use the complete client guide for resource checks, safe retries, secret storage, and recovery after uncertain responses.

x402 is an HTTP payment standard. The first request returns “payment required”; the client signs the exact offer and repeats the same request.

Endpointhttps://app.popcorn.reclaimprotocol.org/v1/x402/sessions
NetworkBase mainnet · eip155:8453
AssetUSDC · 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913
Payee0x28f26a191D6bCa1FfD129261E726033188d65138
Price10,000 atomic units · $0.01
Time300 seconds per block

Security you can verify

Verify the protected environment.
Approve the browser image.

Every public browser lets you request fresh evidence from its hardware-protected environment. Your system verifies that evidence before it trusts the browser.

THE PROOF CONFIRMS

Protected environment.
Approved software.
Fresh evidence.

THE PROOF DOES NOT REPLACE

Your agent permissions, secret handling, network controls, or application security.

The detailed explanation below covers the exact boundary.

THE TRUST GATE

A proof passes only when every signal agrees.

Request /proof/<browser-id>?nonce=<fresh-value> from the browser’s gateway, then ask:

Is it mine and is it fresh?

The challenge matches exactly and the timestamp is recent.

Is the environment protected?

The platform signature and hardware claims satisfy your policy.

Is the expected software running?

The browser and security-service identities match your approved versions.

REPRESENTATIVE PROOF FIELDS
proof_versionv3
noncematches
workload.image_digestapproved
verifier.image_digestapproved
attestation.tokensigned
ALL CHECKS PASSTrust and connect
ANY CHECK FAILSReject the browser ×
What successful verification means — detailed explanation

The two technical terms

A Trusted Execution Environment (TEE) is hardware designed to isolate a workload from the host machine. Attestation is signed evidence that lets another system verify that protected environment and the software loaded inside it.

What a passing result tells you

The evidence is fresh and tied to the random challenge you created. It identifies the browser and security-service images running for that workload, reports whether those images have approved signatures, and carries signed claims about the protected cloud environment.

When all policy checks pass, your system has evidence that the browser was running in the expected protected environment with the approved workload images at the time the proof was created.

What your verifier must check

Popcorn provides evidence; your verifier makes the trust decision. Check exact nonce equality, timestamp freshness, proof version, signer identity, expected image digests, platform-token signature and audience, hardware claims, and binding to the intended workload. Popcorn’s open-source deployment does not currently include a complete policy verifier.

What it does not prove

A valid proof describes one workload at one point in time. It does not prove that every website is safe, that an agent will behave correctly, or that credentials cannot be exposed elsewhere. It does not replace access control, secret handling, network policy, or application security.

Production track record

Two numbers,
clearly scoped.

These are historical observations from Popcorn’s original production workload. They show prior usage and ready-browser assignment speed—not a guarantee for every future task or region.

HISTORICAL USAGE100,000+Total browser sessions handled at the time of measurement
READY CAPACITY460 msMedian time to assign a browser that was already warmed and waiting

Historical measurements only · not an availability or latency SLA.

Everything else

Questions before
you connect.

For implementation details, retry rules, and the complete security model, use the open-source documentation.

Browse all documentation
Do agents need a Popcorn account or API key?

No. The public pay-per-use endpoint creates a browser after the agent pays the returned payment request. Larger integrations can use managed credentials instead.

Can an agent use Playwright?

Yes. A paid session returns a connection URL that Playwright can use. It also returns a live browser view for a human to watch or take over.

How long does a session last?

A new public session buys five minutes. The same browser can be extended in whole five-minute blocks, and its connection URLs remain stable during an extension.

Does Popcorn receive the wallet’s private key?

No. Payment is signed inside the agent’s wallet or custody system. Popcorn receives the signed payment authorization, not the private key.

Can I verify a public pay-per-use session?

Yes. Public sessions can provide a fresh runtime proof. Send a new random challenge, retrieve the proof for that browser, and verify the protected hardware, approved software images, signer, and freshness before trusting it.

What must be kept secret?

The payment signature, session ID, Playwright connection, and live-view URL act like temporary passwords. Keep them out of logs and analytics, and terminate a session if one may have leaked.

Enterprise integration

Need a browser environment built around your agents?

Self-serve access and runtime verification need no form. Talk to us when you need dedicated capacity, higher concurrency, specific regions, managed credentials, private networking, or engineering support.

  • Private networking and access
  • Dedicated capacity and regions
  • Custom access, networking, and support

ENTERPRISE INTEGRATION

Plan a larger deployment.

For self-serve access, use the public x402 API above—no form required.