Screenshots for AI agents

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
import { withX402Client } from "agents/x402";
import { privateKeyToAccount } from "viem/accounts";

const transport = new StreamableHTTPClientTransport(new URL("https://screenshotx402.com/mcp"));
const mcp = new Client({ name: "agent", version: "1.0.0" });

const account = privateKeyToAccount(process.env.AGENT_PRIVATE_KEY as `0x${string}`);

const paidClient = withX402Client(mcp, {
  account,
  network: "base",
  maxPaymentValue: 100_000n,
});

await paidClient.connect(transport);

const result = await paidClient.callTool(null, {
  name: "take_screenshot",
  arguments: { url: "https://example.com", fullPage: false },
});

import asyncio

from mcp.client.session import ClientSession
from mcp.client.streamable_http import streamable_http_client

MCP_URL = "https://screenshotx402.com/mcp"

async def main() -> None:
    async with streamable_http_client(MCP_URL) as (read_stream, write_stream):
        async with ClientSession(read_stream, write_stream) as session:
            await session.initialize()
            result = await session.call_tool(
                "take_screenshot",
                {"url": "https://example.com", "fullPage": False},
            )
            print(result)

# Paid tools: on HTTP 402, attach x402 payment headers on retry (https://www.x402.org/).
# TypeScript tab: withX402Client is the reference payment wrapper.

if __name__ == "__main__":
    asyncio.run(main())

package main

import (
	"context"
	"log"
	"net/http"

	"github.com/modelcontextprotocol/go-sdk/mcp"
)

func main() {
	ctx := context.Background()
	mcpURL := "https://screenshotx402.com/mcp"

	client := mcp.NewClient(&mcp.Implementation{Name: "agent", Version: "1.0.0"}, nil)
	transport := &mcp.StreamableClientTransport{
		Endpoint:   mcpURL,
		HTTPClient: &http.Client{}, // add Transport for x402 payment retries on HTTP 402
	}
	session, err := client.Connect(ctx, transport, nil)
	if err != nil {
		log.Fatal(err)
	}
	defer session.Close()

	res, err := session.CallTool(ctx, &mcp.CallToolParams{
		Name: "take_screenshot",
		Arguments: map[string]any{
			"url":      "https://example.com",
			"fullPage": false,
		},
	})
	if err != nil {
		log.Fatal(err)
	}
	_ = res
}

use serde_json::json;

fn main() {
	let mcp_url = "https://screenshotx402.com/mcp";
	let arguments = json!({
		"url": "https://example.com",
		"fullPage": false
	});
	println!("MCP {mcp_url} — tool take_screenshot args {arguments}");
	// Connect with an MCP Streamable HTTP client from your stack, then call_tool with arguments.
	// Paid tools: on HTTP 402, attach x402 payment proof and retry (https://www.x402.org/).
}