Every way in. Zero API keys.

One URL, native tools everywhere.

A hosted, stateless streamable-HTTP MCP server — nothing to install, nothing to run. Point any remote-MCP client at the endpoint and all 75 tools appear, generated live from the API's OpenAPI spec so new endpoints show up automatically.

Claude — claude.ai, Desktop & Claude Code

claude.ai & Claude Desktop: Settings → Connectors → Add custom connector, paste the endpoint URL above, done. In Claude Code it's one command:

claude mcp add --transport http webbersites https://api.webbersites.com/mcp

Claude Desktop also has a one-click .mcpb extension that runs the server locally — the wallet key stays in your OS keychain instead of a connection URL.

ChatGPT & the OpenAI Agents SDK

ChatGPT: connectors live behind developer mode — Settings → Apps & Connectors → Advanced settings → Developer mode, then Create connector with the endpoint URL above (paid plans; no authentication). In agentic code, the Agents SDK attaches the same server as a hosted tool:

import { Agent, run, hostedMcpTool } from "@openai/agents";

const agent = new Agent({
  name: "data-agent",
  tools: [hostedMcpTool({
    serverLabel: "webbersites",
    serverUrl: "https://api.webbersites.com/mcp",
  })],
});

const result = await run(agent, "What does an SEO audit of example.com cost?");

Gemini CLI

{
  "mcpServers": {
    "webbersites": {
      "httpUrl": "https://api.webbersites.com/mcp"
    }
  }
}

{
  "mcpServers": {
    "webbersites": {
      "url": "https://api.webbersites.com/mcp"
    }
  }
}

{
  "servers": {
    "webbersites": {
      "type": "http",
      "url": "https://api.webbersites.com/mcp"
    }
  }
}

Making paying calls

With no configuration the server runs in quote mode — every tool answers with its live price and x402 payment requirements instead of data. To let tools actually pay, append a wallet key to the connection URL:

https://api.webbersites.com/mcp?evmPrivateKey=0xYOUR_THROWAWAY_KEY&maxPrice=0.10

maxPrice is a hard USD ceiling per call — anything dearer is refused before payment. The key rides along with your connection config to our server, so use a dust wallet only; if you'd rather the key never leave your machine, use the local npx server instead. The full config schema is published at /mcp/.well-known/mcp-config.

One line, and your agent knows the catalog.

Published to ClawHub, the OpenClaw skill registry. Installing teaches your agent what's here, how to pay for it, and the conventions that make it stick — a scratchpad named index so it never forgets it has memory, and ping on a cron for monitoring.

Install

openclaw skills install x402-agent-tools

Paying for calls

The skill is client-agnostic — any x402 wallet works. If your agent already has the agentcash-wallet skill installed, it can discover prices and execute paid calls against api.webbersites.com with no extra setup: it handles the 402 challenge, signs the USDC payment on Base, and retries. Payments settle only on a 2xx, so failed requests cost nothing.

clawhub search "x402 agent tools"

Same tools, key stays home.

The webbersites-x402-mcp package runs the MCP server on your machine over stdio. Your wallet key lives in a local env var and never leaves the process — payments are signed locally and only the signed authorization travels. Tools are generated from the live OpenAPI spec at startup, so it never goes stale.

Claude Code

claude mcp add webbersites-x402 \
  -e EVM_PRIVATE_KEY=0xYOUR_KEY \
  -- npx -y webbersites-x402-mcp

{
  "mcpServers": {
    "webbersites-x402": {
      "command": "npx",
      "args": ["-y", "webbersites-x402-mcp"],
      "env": { "EVM_PRIVATE_KEY": "0xYOUR_KEY" }
    }
  }
}

{
  "mcpServers": {
    "webbersites-x402": {
      "command": "npx",
      "args": ["-y", "webbersites-x402-mcp"],
      "env": { "EVM_PRIVATE_KEY": "0xYOUR_KEY" }
    }
  }
}

Environment variables

Fund the wallet with a dollar of USDC on Base — that's roughly 1,000 of the cheapest calls.

One click, hosted for you.

The server is listed on Smithery, the MCP registry with a hosted gateway. Connect through Smithery's UI and it handles the plumbing for whatever client you use — no terminal, no config files.

How it works

Connect with zero config and you're in quote mode — browse all 75 tools and their live prices for free. When you're ready to make paying calls, set two fields in Smithery's connection settings:

Tools as a package.

Building your own agent? webbersites-agent-tools hands you all 75 endpoints as ready-made tool objects — { name, description, parameters, execute } — with adapters for the Vercel AI SDK and LangChain, and a shape that maps 1:1 onto Coinbase AgentKit custom actions. Definitions are built at runtime from the live OpenAPI spec, so the package never goes stale.

npm install webbersites-agent-tools

Quickstart

import { createWebbersitesTools } from "webbersites-agent-tools";

const { tools, byName } = await createWebbersitesTools({
  privateKey: process.env.EVM_PRIVATE_KEY, // dust wallet with a little USDC on Base
});

const price = await byName.get_price_coin.execute({ coin: "bitcoin" });
// { coin: "bitcoin", usd: …, change_24h_pct: …, ts: "…" }  — cost: $0.001

import { generateText, tool, jsonSchema } from "ai";
import { createWebbersitesTools, toVercelAI }
  from "webbersites-agent-tools";

const { tools } = await createWebbersitesTools({
  privateKey: process.env.EVM_PRIVATE_KEY,
});

const result = await generateText({
  model: yourModel,
  tools: toVercelAI(tools, { tool, jsonSchema }),
  prompt: "Audit example.com for SEO.",
});

import { DynamicStructuredTool }
  from "@langchain/core/tools";
import { createWebbersitesTools, toLangchain }
  from "webbersites-agent-tools";

const { tools } = await createWebbersitesTools({
  privateKey: process.env.EVM_PRIVATE_KEY,
});
const lcTools = toLangchain(tools, { DynamicStructuredTool });

Quote mode & subsets

// Omit privateKey — every tool returns its live price + payment
// requirements instead of data. Browse before you fund.
const { tools, quoteMode } = await createWebbersitesTools();

// Or hand your agent just the tools you want it spending on:
const { tools: lintOnly } = await createWebbersitesTools({
  privateKey,
  filter: (t) => t.path.startsWith("/api/lint/"),
});

No wrapper. Just the protocol.

Everything above is convenience — underneath, this is plain HTTP. Call any endpoint, get a 402 Payment Required quote, sign a USDC transfer authorization (EIP-3009, no gas from you), retry with the X-PAYMENT header. Any language, any runtime, no SDK required.

# 1 — call an endpoint, no payment yet
curl -i https://api.webbersites.com/api/price/bitcoin

# → the server answers with what it costs:
HTTP/1.1 402 Payment Required
{
  "x402Version": 1,
  "accepts": [{
    "scheme": "exact",
    "network": "eip155:8453",
    "asset": "USDC",
    "maxAmountRequired": "1000"  // $0.001
  }]
}

import { wrapFetchWithPayment } from "@x402/fetch";
import { createWalletClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { base } from "viem/chains";

const account = privateKeyToAccount(process.env.AGENT_KEY);
const wallet  = createWalletClient({ account, chain: base, transport: http() });

// a fetch that pays 402s for you
const fetchPaid = wrapFetchWithPayment(fetch, wallet);

const res  = await fetchPaid("https://api.webbersites.com/api/report/ethereum");
const data = await res.json(); // 200 OK — you're done

Worth knowing

Rewards: any purchase over $0.001 opens a 24-hour window in which every $0.001 endpoint costs $0.0005 for your wallet — add an X-Wallet: 0xYourAddress header (or ?wallet=) and the 402 quote reflects the discount automatically. The full worked payment flow, with request and response examples for every endpoint, is in llms-full.txt.

Same 402. Three rails.

Every paid endpoint also speaks MPP — the Machine Payments Protocol, the Tempo/Stripe IETF draft that standardizes HTTP 402 into WWW-Authenticate: Payment challenges. Same USDC amount, same wallet, same on-chain settlement as x402 — only the wire format differs. If your agent's stack already carries an mppx client (Vercel AI SDK, Cloudflare Agents, the official MCP SDK, OpenClaw), it pays here with zero configuration: no listing to find, no key to register — the 402 itself is the integration.

# any paid endpoint, no payment yet
curl -i https://api.webbersites.com/api/price/bitcoin

# → alongside the x402 quote, the same 402 carries:
HTTP/1.1 402 Payment Required
WWW-Authenticate: Payment id="…",
  method="evm", intent="charge",
  request="…"  // amount, USDC on Base, pay-to

// npm install mppx viem
import { Fetch, evm } from "mppx/client";
import { privateKeyToAccount } from "viem/accounts";

const fetchPaid = Fetch.from({
  methods: [evm.charge({
    account: privateKeyToAccount(process.env.AGENT_KEY),
    currencies: [evm.assets.base.USDC],
    maxAmount: "1.00",  // per-call ceiling
  })],
});

const res  = await fetchPaid("https://api.webbersites.com/api/report/ethereum");
const data = await res.json(); // 200 — receipt in Payment-Receipt header

Worth knowing

Discovery: MPP-aware agents find the full paid catalog at /.well-known/mpp.json; every API response also carries a Link: rel="payment-method" breadcrumb pointing there. Protocol spec: mpp.dev. Prefer Bitcoin? The same 402 also carries a Lightning rail — opt in with an X-Pay-With: l402 header for a BOLT11 invoice challenge. Full guide at l402.webbersites.com.

Built for machines to find.

Agents shouldn't need a docs page. Every endpoint, price, schema, and payment requirement is published at stable, machine-readable URLs — point your agent at any one of them and it can discover the rest itself. These are the source of truth; they update the moment the API does.

Tell your agent one sentence: "Read https://api.webbersites.com/.well-known/x402 and use what you need." Prices, new endpoints, and payment details stay current with zero code changes on your side.