---
title: Popcorn — x402 browsers for AI agents
description: Pay-per-use remote Chromium sessions for AI agents with Playwright control, a live human view, and verifiable runtime proofs.
canonical_url: https://popcorn.reclaimprotocol.org/
markdown_url: https://popcorn.reclaimprotocol.org/ai.md
last_updated: 2026-08-10
---

# Popcorn

Popcorn provides isolated remote Chromium browsers for AI agents. An agent can create a public session without an account or API key, pay $0.01 for a five-minute block using USDC on Base, control the browser with Playwright, and share a live view with a human.

## Key facts

- Product: remote browser infrastructure for AI agents.
- Public session price: $0.01 per five-minute block (x402).
- MCP access: OAuth over Streamable HTTP with prepaid credits — one credit is 10 minutes of browser time, and a $5 checkout buys 100 credits.
- Signup: not required for public pay-per-use access.
- Agent control: Playwright over a returned CDP WebSocket URL.
- Human control: a live-view URL for the same browser.
- Isolation: a dedicated browser session for one task, removed afterward.
- Verification: a fresh runtime proof is available for public sessions.
- Larger deployments: dedicated capacity, regions, managed access, private networking, and support are available by enquiry.
- Self-hosting: the deployment and documentation are open source.
- Hosted MCP: compatible clients can connect to `https://popcorn-mcp-gcp.reclaimprotocol.org/mcp` using Streamable HTTP and OAuth.

## Hosted MCP access

For the fastest agent integration, add the remote Streamable HTTP endpoint:

`https://popcorn-mcp-gcp.reclaimprotocol.org/mcp`

The hosted MCP server uses browser OAuth and does not require an API key, Stripe secret, or client environment variable. See the [client-neutral Popcorn MCP guide](https://popcorn.reclaimprotocol.org/mcp/) for generic configuration, client recipes, tools, billing, retry behavior, and human handoff.

## Public session endpoint

`POST https://app.popcorn.reclaimprotocol.org/v1/x402/sessions`

For clients that support remote Streamable HTTP MCP servers and OAuth, see the separate [client-neutral Popcorn MCP guide](https://popcorn.reclaimprotocol.org/mcp/). The MCP credit model and the public x402 endpoint are separate access methods.

The endpoint uses x402, an HTTP payment protocol. The first request returns `402 Payment Required` with an offer. After validating the offer, the agent signs the exact authorization in its wallet and repeats the request with the payment signature. A successful response returns the browser connection details.

### Terms the client must validate

| Term | Expected value |
| --- | --- |
| Network | Base mainnet, `eip155:8453` |
| Chain ID | `8453` |
| Asset | USDC, `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` |
| Payee | `0x28f26a191D6bCa1FfD129261E726033188d65138` |
| Amount | `10000` atomic units, equal to $0.01 at 6 decimals |
| Session time | 300 seconds per block |

Reject a challenge when any network, asset, receiver, or amount differs from the trusted policy. Payment signing happens inside the agent's wallet or custody system; Popcorn does not receive the private key.

## Request flow

1. Send an empty JSON `POST` request to the public session endpoint.
2. Receive `402 Payment Required` and the payment offer.
3. Validate the exact network, token, receiver, and maximum amount.
4. Sign the offer in the agent wallet and repeat the same request with `PAYMENT-SIGNATURE`.
5. Receive `200 OK` with `connectUrl`, `liveViewUrl`, and `expiresAt`.
6. Request and verify a fresh runtime proof before sharing sensitive data.
7. Connect Playwright with `chromium.connectOverCDP(session.connectUrl)`.
8. Extend the same browser in whole five-minute blocks when needed, or end it after the task.

Use a unique `Idempotency-Key` for session creation and follow the complete client guide for retry and recovery behavior.

## Minimal TypeScript client

Requirements: Node.js 20 or Bun, an EVM wallet funded with Base USDC, and enough ETH on Base for network gas.

```bash
npm install mppx@0.8.15 viem@2.55.10 playwright
```

```typescript
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 is a minimal first-session example. The complete client guide covers resource checks, safe retries, secret storage, and recovery after uncertain responses.

## Runtime verification

Request a proof from the browser gateway at:

`/proof/<browser-id>?nonce=<fresh-random-value>`

The relying system—not Popcorn—makes the trust decision. It must verify:

- exact equality with the newly generated nonce;
- timestamp freshness and the supported proof version;
- the platform token signature, audience, signer identity, and hardware claims;
- binding to the intended workload;
- the browser workload image digest against an approved value;
- the verifier image digest against an approved value.

A passing proof is evidence that the browser was running in the expected protected environment with approved workload images when the proof was created. It does not prove that every visited website is safe, that an agent will behave correctly, or that credentials cannot leak elsewhere. Continue to enforce agent permissions, secret handling, network policy, and application security.

## Session and secret handling

- Treat the payment signature, session ID, Playwright connection URL, and live-view URL as temporary secrets.
- Do not put those values in logs, analytics, issue trackers, or prompts shared with unrelated systems.
- Give the Playwright URL only to the process that owns the session.
- Terminate a session when a connection value may have leaked.
- An extension keeps the browser and its connection URLs stable while adding another five-minute block.
- Unused session time is not refunded.

## Production options

Public pay-per-use access is intended for immediate self-serve use. Contact the Popcorn team through the form on the canonical page when an integration needs dedicated capacity, higher concurrency, specific regions, managed credentials, private networking, or engineering support.

The open-source version can be deployed in your own cloud with your preferred network and isolation model.

## Performance context

Popcorn previously handled more than 100,000 browser sessions. A historical measurement showed a 460 ms median assignment time when a warmed browser was already waiting. These observations are not an availability or latency service-level agreement.

## Authoritative resources

- [Canonical product page](https://popcorn.reclaimprotocol.org/): Human-readable product overview and enterprise enquiry form.
- [MCP integration guide](https://popcorn.reclaimprotocol.org/mcp/): Generic Streamable HTTP and OAuth setup for compatible MCP clients.
- [Complete x402 client guide](https://github.com/reclaimprotocol/popcorn-oss/blob/main/docs/x402-client.md): Payment validation, retries, resource checks, and production client behavior.
- [Runtime verification guide](https://github.com/reclaimprotocol/popcorn-oss/blob/main/docs/attestation.md): Proof format and verification policy.
- [All documentation](https://github.com/reclaimprotocol/popcorn-oss/tree/main/docs): Open-source technical documentation.
- [Source repository](https://github.com/reclaimprotocol/popcorn-oss): Self-hosted Popcorn deployment.
- [Why Popcorn was built](https://blog.reclaimprotocol.org/posts/why-we-built-popcorn): Product background.

## Sitemap

See the [semantic sitemap](https://popcorn.reclaimprotocol.org/sitemap.md) or the [LLM index](https://popcorn.reclaimprotocol.org/llms.txt) for all public machine-readable resources.