Screenshot a page

A picture of a page, taken in a real browser after its JavaScript has run. An agent cannot look at a page; this is the closest it gets — checking that a deploy renders, that a banner says what it claims, or handing a person an image of what the agent found. Viewport is yours to set, or capture the full scrolling page.

POST https://api.bottrunk.com/s/screenshot-url

Add to my agent

Overview Call it Behaviour Input Output

Call it

# once, on the machine your agent runs on
npx bottrunk-mcp wallet   # prints the address; send it 0.3 ALGO, then USDC
claude mcp add bottrunk -- npx -y bottrunk-mcp

# then ask your agent for it — the tool is `bottrunk_screenshot_url`

# Ask. You get a 402 with the payment requirements.
curl https://api.bottrunk.com/s/screenshot-url \
  -H "Content-Type: application/json" \
  -d '{"url":"https://example.com/pricing","width":1280,"height":800,"wait_for":"main img"}'

# Pay and retry. Any x402 client does this for you.
curl https://api.bottrunk.com/s/screenshot-url \
  -H "PAYMENT-SIGNATURE: <signed USDC transfer>" \
  -H "Content-Type: application/json" \
  -d '{"url":"https://example.com/pricing","width":1280,"height":800,"wait_for":"main img"}'

# pip install "x402-avm[avm,requests]==2.0.2"
import base64, os
from algosdk import encoding, mnemonic
from x402 import x402ClientSync
from x402.http import x402HTTPClientSync
from x402.http.clients.requests import x402_requests
from x402.mechanisms.avm import ALGORAND_MAINNET_CAIP2
from x402.mechanisms.avm.exact import ExactAvmScheme

class MnemonicSigner:  # signs the payment with your agent's 25-word mnemonic
    def __init__(self, words):
        self._sk = mnemonic.to_private_key(words)
        self.address = encoding.encode_address(base64.b64decode(self._sk)[32:])

    def sign_transactions(self, unsigned_txns, indexes_to_sign):
        return [base64.b64decode(encoding.msgpack_encode(
                    encoding.msgpack_decode(base64.b64encode(t).decode()).sign(self._sk)))
                if i in indexes_to_sign else None
                for i, t in enumerate(unsigned_txns)]

# A wallet holding 0.3 ALGO, opted in to USDC, funded with the USDC it may spend.
signer = MnemonicSigner(os.environ["ALGORAND_MNEMONIC"])
client = x402ClientSync().register(ALGORAND_MAINNET_CAIP2,
    ExactAvmScheme(signer, algod_url="https://mainnet-api.algonode.cloud"))

with x402_requests(client) as session:   # answers the 402, pays, retries
    r = session.post("https://api.bottrunk.com/s/screenshot-url", json={"url": "https://example.com/pricing", "width": 1280, "height": 800, "wait_for": "main img"})
    print(r.json())
    receipt = x402HTTPClientSync(client).get_payment_settle_response(r.headers.get)
    print(receipt.transaction)            # the settlement on-chain

// npm install @x402-avm/fetch @x402-avm/avm @x402-avm/core algosdk
import algosdk from "algosdk";
import { x402Client } from "@x402-avm/core/client";
import { ExactAvmScheme } from "@x402-avm/avm/exact/client";
import { toClientAvmSigner } from "@x402-avm/avm";
import { wrapFetchWithPayment } from "@x402-avm/fetch";

// A wallet holding 0.3 ALGO, opted in to USDC, funded with the USDC it may spend.
const { sk } = algosdk.mnemonicToSecretKey(process.env.ALGORAND_MNEMONIC!);
const signer = toClientAvmSigner(Buffer.from(sk).toString("base64"));
const client = new x402Client().register("algorand:wGHE2Pwdvd7S12BL5FaOP20EGYesN73ktiC1qzkkit8=",
  new ExactAvmScheme(signer, { algodUrl: "https://mainnet-api.algonode.cloud" })); // default is TestNet
const fetchWithPay = wrapFetchWithPayment(fetch, client);

const r = await fetchWithPay("https://api.bottrunk.com/s/screenshot-url", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({"url":"https://example.com/pricing","width":1280,"height":800,"wait_for":"main img"}),
});
console.log(await r.json());

How it behaves

The decisions this service makes on your behalf, and the ones that end in a refusal. A 4xx is never settled, so a refusal costs you nothing.

What comes back	The PNG as base64 in image_base64, with the real pixel size read off the file. Base64 is about a third larger than the file itself; budget for that.
Size limit	A render over 1.5 MB is refused with 422 and not charged, rather than returning a JSON body nobody wants. Narrow the viewport or drop full_page and try again.
Viewport	width and height are clamped to 240–3840. With full_page the height grows to whatever the page needs, so the returned height is what was captured, not what was asked for.
Waiting for content	wait_for takes a CSS selector the browser waits for before the shutter — the difference between catching a page mid-spinner and after its data lands.
If the renderer is busy	The free renderer runs one browser at a time. A busy answer is retried once, then the call fails and is never settled, so it costs you nothing.
Size and time	Pages over 2 MB are refused with page too large. Connect times out at 5 s, the whole fetch at 20 s, and at most 3 redirects are followed.
Who we look like	Requests go out as BotTrunk/0.1 (+https://bottrunk.com/docs). Sites that block unknown agents will block this one.
Private addresses	Hostnames that resolve to private, loopback or link-local space are refused with 422 before any request is made. Do not point this at localhost or an intranet.
Method	POST only. A GET on the same path returns this page.

Input

url	string	Public http(s) URL to capture.
full_page	boolean	Capture the whole scrolling page instead of one viewport.
width	integer	Viewport width in pixels, 240–3840. Default 1280.
height	integer	Viewport height in pixels, 240–3840. Default 800.
wait_for	string	Optional CSS selector to wait for before capturing.

Output

image_base64	string	The PNG, base64-encoded.
width	integer	Captured width in pixels.
height	integer	Captured height in pixels.
bytes	integer	Size of the PNG before encoding.
captured_at	string	When the shot was taken, UTC.