Skavio USDC Paid Micro-APIs

遠端 MCP 伺服器，具備 18 項工具，用於 Base 與 Solana 上的 USDC x402 支付、付款驗證、PDF 證據、DNS/TLS 檢查及經驗證的 AI/文件處理。

託管 MCP 伺服器

npx add-mcp 'https://www.skavio.eu/mcp'

可安裝到 Claude Code、Codex、Cursor 等客戶端

文件

How it works

Make a GET request. The first response returns HTTP 402 Payment Required and a PAYMENT-REQUIRED header with the exact amount, asset, Base network and receiver. An x402-compatible client signs a payment and retries with the PAYMENT-SIGNATURE header. The facilitator verifies and settles the payment; only then can the protected API return its result.

GET https://getskavio.com/x402/v1/usdc/verify?tx_hash=0x...&network=base
→ HTTP 402 · native USDC / eip155:8453 · 0.02 USDC
→ Client submits signed x402 payment
→ Paid GET response: JSON evidence

No wallet private keys are shared with Skavio. Do not send seed phrases. All data endpoints are read-only.

Verify a native USDC transaction

GET /x402/v1/usdc/verify

tx_hash=0x...  (EVM hash) or Solana base58 transaction signature
network=base | polygon | arbitrum | optimism | ethereum | avalanche | solana

Returns blockchain, native token address/mint, confirmation or finalization status, transfer owners, native USDC amounts and transaction timestamp. Pending / not fully confirmed transfers are never reported as finalized.

Match exact recipient and amount

GET /x402/v1/usdc/match

tx_hash=0x... (or Solana base58 signature)
network=polygon
recipient=0x... (for Solana: base58 owner wallet)
amount=12.500000

Returns matched: true only when exactly one finalized native USDC transfer matches the recipient and exact six-decimal amount. Duplicate matching transfers return false to avoid ambiguity.

Download transaction evidence PDF

GET /x402/v1/usdc/evidence.pdf

tx_hash=0x... (or Solana base58 signature)
network=ethereum

Returns a timestamped PDF document of public blockchain evidence. It is not a tax invoice, receipt for a commercial sale or a guarantee of third-party authorization.

New web Search / Fetch / Extract: HTTP contract and SDKs

The three primary tools are Search, Fetch and Extract; Extract + Analyze is an additional fourth paid variant. These operations are public HTTP POST endpoints, NOT new MCP tool names. No separate API key for this x402 API; a wallet with native Circle USDC on Base (eip155:8453) must authorize each payment. Your other Processing API SDK uses bearer keys/credits and is independent.

Tool	Endpoint	Price	What it returns	JSON request example
Web Search	`POST /x402/v1/web/search`	0.02 USDC	DeepSeek Search; ranked public URLs, titles, snippets, optional bounded content.	`{"query":"invoice automation EU","count":5}`
Web Fetch	`POST /x402/v1/web/fetch`	0.01 USDC	DeepSeek Fetch; bounded Markdown/plain text from a public URL.	`{"url":"https://example.com","output_format":"markdown"}`
Web Extract	`POST /x402/v1/web/extract`	0.02 USDC	Deterministic title, headings, metadata and readable blocks, with source URL; no model analysis.	`{"url":"https://example.com/article"}`
Extract + Analyze	`POST /x402/v1/web/extract/analyze`	0.03 USDC	Optional fourth endpoint: deterministic extraction followed by bounded DeepSeek Flash analysis.	`{"url":"https://example.com/article","instruction":"Summarize the key claims"}`

Workflow: send JSON POST without payment → server returns free HTTP 402 and PAYMENT-REQUIRED with Base USDC merchant, price and requirements → x402 v2 wallet verifies amount/network/payee → signs authorization → retries the identical POST body with PAYMENT-SIGNATURE → on success inspect PAYMENT-RESPONSE and JSON output. No seed phrase or private key is ever sent to Skavio. Do not send payment automatically without an explicit spend policy.

Free quote / curl (returns HTTP 402)

# First request does not spend funds; inspect HTTP 402 and PAYMENT-REQUIRED.
curl -i -X POST https://getskavio.com/x402/v1/web/search \
  -H 'Content-Type: application/json' \
  -d '{"query":"invoice OCR for small businesses","count":5}'

# Compatible x402-v2 wallet SDK verifies offered Base USDC amount/payee,
# signs the exact authorization and retries the SAME method + JSON body
# using the PAYMENT-SIGNATURE header. Never send seed phrases to Skavio.

TypeScript / JavaScript x402 SDK

npm install @x402/fetch @x402/evm viem

// Node.js / trusted backend, Base mainnet native Circle USDC.
// Store the payer key in a secret manager, never in a website/client bundle.
import { wrapFetchWithPayment, x402Client } from "@x402/fetch";
import { registerExactEvmScheme } from "@x402/evm/exact/client";
import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount(process.env.EVM_PRIVATE_KEY);
const client = new x402Client();
registerExactEvmScheme(client, { signer: account, networks: ["eip155:8453"] });
const paidFetch = wrapFetchWithPayment(fetch, client, {
  paymentRequirementsSelector: accepts =>
    accepts.find(item => item.network === "eip155:8453")
});

// Inspect price and recipient, enforce your own spending cap before permitting a signature.
const response = await paidFetch("https://getskavio.com/x402/v1/web/search", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ query: "EU invoice automation", count: 5 })
});
if (!response.ok) throw new Error("Skavio HTTP " + response.status);
console.log(await response.json());
// For fetch/extract replace the path and body with {url:"https://example.com"}.

Python x402 SDK

pip install "x402[httpx,evm]"

# Python 3.10+; run only on a trusted backend; never hardcode wallet keys.
import asyncio, os
from eth_account import Account
from x402 import x402Client
from x402.http.clients import x402HttpxClient
from x402.mechanisms.evm import EthAccountSigner
from x402.mechanisms.evm.exact.register import register_exact_evm_client

async def main():
    client = x402Client()
    account = Account.from_key(os.environ["EVM_PRIVATE_KEY"])
    register_exact_evm_client(client, EthAccountSigner(account))
    # Confirm the offered network, payee and amount and enforce a spend cap.
    async with x402HttpxClient(client) as http:
        r = await http.post(
            "https://getskavio.com/x402/v1/web/fetch",
            json={"url": "https://example.com", "output_format": "markdown"},
            timeout=30
        )
        r.raise_for_status()
        print(r.json())

asyncio.run(main())

Request limits and errors: Search query 1–128 chars, count 1–10; Fetch url (public HTTP(S)), max_bytes 1 KiB–2 MiB and output_format markdown/text; Extract url, optional max_bytes; Analyze adds optional instruction up to 1,000 chars. Validation 422, body too large 413, replay with changed body 409, provider failures 502/503/504. Empty Search can legitimately return an empty results array. Allowlist destinations, cap spending, and do not assume every site can be fetched.

Production evidence: HTTP 402 challenge confirmed on all four routes. A funded Web Fetch execution of 0.01 USDC was verified in the production settlement journal on 28 October 2026; other web tools are not yet individually funded-tested. Actual OpenAPI input/output schemas · Seven-resource machine discovery · Official open-source x402 SDKs. Customer support: support@getskavio.com.

Connect Skavio as a paid MCP server

Use our public Streamable HTTP endpoint in an MCP client: https://getskavio.com/mcp. Discovery of all tools and the free skavio_catalog tool require no payment. The server offers these paid tools:

verify_native_usdc(tx_hash, network="base")     0.02 USDC
match_native_usdc_payment(tx_hash, recipient, amount, network="base")   0.03 USDC
usdc_transfer_evidence_pdf(tx_hash, network="base")  0.05 USDC
domain_dns_tls_audit(domain)                   0.05 USDC

Payment protocol: x402 MCP transport v2. An unpaid tool call returns a machine-readable PaymentRequired result, including the native Circle USDC address on eip155:8453. An x402-capable agent prepares its own signed payment, retries with params._meta["x402/payment"], and the server independently verifies, executes and settles the transaction.

General MCP clients can browse the catalog. Paid execution requires an x402-aware MCP client capable of signing payments. The MCP server cannot access a buyer's wallet, and Skavio never requests private keys. A standard x402 HTTPS API is also available above.

Documentation for automated agents

Exact merchant prices are in the HTTP 402 payment challenge and never change according to the blockchain being inspected. Payment chain is eip155:8453, not the selected inspection network. Network data is sourced from independent public RPC providers and can be temporarily unavailable.

Production availability

Public USDC verification, matching, PDF evidence and DNS/TLS tools use per-call x402 fees. PayAPI publishes separate historical settlement receipts for HTTP Verify, Match and PDF evidence; each route is linked below. Authenticated processing uses separate company credentials and backend operation availability; no funded processing acceptance or profitability is asserted here.

The HTTP /x402/v1/processing routes are disabled. A wallet-capable x402 extension is required for paid MCP calls.

HTTP availability policy · Authenticated processing catalog

Find Skavio in AI Agent Marketplaces

Skavio USDC Payment Verification — x402 API. Inspect seven blockchains; pay API fees in native Circle USDC on Base. Verify 0.02 USDC, Match 0.03 USDC, PDF evidence 0.05 USDC per call.

Official MCP Registry: paid verification and proof MCP — published remote server; stable name eu.skavio/paid-micro-apis.
PayAPI Market: USDC transaction verification — settlement-verified /verify, 0.02 USDC. Each link below has its own published historical receipt; this is not a new paid test.
PayAPI Market: exact recipient and amount matching — independently settlement-verified /match, 0.03 USDC.
PayAPI Market: blockchain PDF payment evidence — independently settlement-verified /evidence.pdf, 0.05 USDC. Blockchain evidence is not a tax invoice.
x402scan: three HTTP resources — registered; external display metadata may lag the API.
x402 List: USDC verification and paid MCP tools — accepted public service profile with three tracked HTTP endpoints.
Glama: paid MCP connector — public imported listing; scan freshness is controlled by the directory.
GitHub: MCP integration and quickstart · HTTP API documentation.

Separate company integration: Skavio PDF, OCR & Document Processing MCP uses company OAuth and shared credits at https://getskavio.com/processing/mcp. These are directory links, not partner endorsements.

Connect an agent and make the first unpaid request

Choose verify_native_usdc to inspect transfers and confirmation status, match_native_usdc_payment for exactly one finalized recipient and amount match, or usdc_transfer_evidence_pdf for blockchain evidence, not a tax invoice. domain_dns_tls_audit checks public DNS and TLS for 0.05 USDC; it is not a vulnerability scan.

A standard MCP client without a wallet x402 extension cannot automatically pay. Adding the server enables discovery; it does not authorize spending. No private key, seed phrase or wallet secret belongs in Skavio requests.

Cursor: remote MCP configuration

Add to your MCP settings or project .cursor/mcp.json. This public connection needs no API key for catalog discovery.

{"mcpServers":{"skavio-usdc":{"url":"https://getskavio.com/mcp"}}}

Claude Code

claude mcp add --transport http skavio-usdc https://getskavio.com/mcp

Equivalent .mcp.json:

{"mcpServers":{"skavio-usdc":{"type":"http","url":"https://getskavio.com/mcp"}}}

Claude Desktop: local bridge configuration

For Desktop versions using local stdio configuration, Node.js and the third-party mcp-remote bridge can connect to the remote server. Review the bridge before running it; npx may download it. This bridge alone does not add wallet payment support. Desktop versions with remote connectors can add the HTTPS URL directly.

{"mcpServers":{"skavio-usdc":{"command":"npx","args":["-y","mcp-remote","https://getskavio.com/mcp"]}}}

REST: an unpaid HTTP 402 example

curl -i 'https://getskavio.com/x402/v1/usdc/verify?tx_hash=0x98809948204426c574b6f0aabdec03baa996b5c43ce28cc9ca704fa5d07e592e&network=base'

This GET requires no key or transfer and returns HTTP 402 with a base64 PAYMENT-REQUIRED header. It does not execute the paid handler. Decode the header to inspect the price, native Base USDC asset, payee, expiry and Bazaar input/output schemas.

Use an x402 v2 compatible wallet client. Inspect the challenge and approve the exact fee before signing; fees are 20000, 30000 or 50000 atomic USDC for Verify, Match or PDF respectively.
The wallet signs a restricted payment authorization. Retry the same HTTP request using PAYMENT-SIGNATURE. MCP clients retry the same tool and arguments with params._meta["x402/payment"]. Never send a private key.
Inspect the returned payment receipt and result. RPC outages, invalid input and insufficient finality can prevent a useful result. Read error and retry guidance; do not blindly create another authorization after an uncertain response.

Inspection networks: Base, Polygon, Arbitrum, Optimism, Ethereum, Avalanche and Solana. Fees always settle on Base. EVM inspection requires a 0x plus 64-hex transaction hash; Solana requires its base58 signature. Match also requires a recipient wallet and positive decimal USDC string with at most six decimal places. EVM thresholds vary by chain; Solana uses finalized data. Public RPC latency and availability are variable; no fixed latency SLA is promised.

Authenticated processing is separate: OAuth Processing MCP documentation · Agent Tools key and job instructions · current operation availability and prices. AgentTools relay calls require a company key, workload quote or prepaid credits, the same idempotency key on retries, then status polling and result SHA256 verification. The HTTP /x402/v1/processing routes remain disabled; there is no anonymous document execution.

Schemas, examples and errors · Three-route discovery manifest · Pinned published MCP manifest · Agent navigation · Developer pricing.

Client references: Cursor MCP · Claude Code MCP. Client support and configuration vary by version.