Your agent
Requests a browser and controls it with familiar automation tools.
Remote browsers for AI agents
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.
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
LIVEPaid block · 05:00 remaining
What Popcorn is
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.
Requests a browser and controls it with familiar automation tools.
Launches, isolates, connects, extends, and cleans up the browser.
Run in a visible Chromium browser with an optional human view.
START NOW
No signup. The agent pays for a short browser session from its own wallet and receives connection links immediately.
LARGER INTEGRATIONS
Keep the same verifiable browser security while adding the capacity, regions, networking, and support your agents need.
RUN IT YOURSELF
Deploy the browser fleet in your own cloud, choose the isolation model, and operate it with the published source and documentation.
The complete flow
Your agent sends one request. Popcorn replies with the price and payment instructions.
The wallet checks the terms, signs a one-time payment, and repeats the same request.
Request a fresh runtime proof and check the protected environment and approved software before sharing sensitive data.
Use Playwright or the live view, buy another five-minute block if needed, then end the browser when the task is complete.
Developer quickstart
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.
Use the verified package versions shown in the full example.
Pin the network, token, receiver, and maximum price before the wallet can sign.
Request a fresh proof and check it against the policy your agent trusts.
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.
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);npm install mppx@0.8.15 viem@2.55.10 playwrightimport { 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.
https://app.popcorn.reclaimprotocol.org/v1/x402/sessionsBase mainnet · eip155:8453USDC · 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA029130x28f26a191D6bCa1FfD129261E726033188d6513810,000 atomic units · $0.01300 seconds per blockSecurity you can verify
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
THE PROOF DOES NOT REPLACE
The detailed explanation below covers the exact boundary.
THE TRUST GATE
Request /proof/<browser-id>?nonce=<fresh-value> from the browser’s gateway, then ask:
The challenge matches exactly and the timestamp is recent.
The platform signature and hardware claims satisfy your policy.
The browser and security-service identities match your approved versions.
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.
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.
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.
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
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 measurements only · not an availability or latency SLA.
Everything else
For implementation details, retry rules, and the complete security model, use the open-source documentation.
Browse all documentation ↗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.
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.
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.
No. Payment is signed inside the agent’s wallet or custody system. Popcorn receives the signed payment authorization, not the private key.
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.
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
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.