Interline
Supports agent-to-agent payments using Circle's USDC stablecoin via x402 protocol on EVM (Base Sepolia) and Solana networks.
Provides a Google-AP2 inbound adapter for signed payment mandates, enabling non-custodial settlement via AP2 authorization.
Enables USDC micropayments on Solana (devnet) through the x402 protocol, allowing agent-to-agent settlement on Solana blockchain.
Interline — agent-to-agent payment router
Archived (2026-10-10). Interline is no longer maintained. The code stays here for reference; nothing is being developed, and the testnet demos are not monitored.
An agent-to-agent payment router: one agent does work, another agent pays for it, no human keys a card. Interline is a neutral, non-custodial router over the fragmented agent-payment-rail stack — "OpenRouter for agent payments." Built on x402 (HTTP-402 micropayments, USDC), aggregator-shaped so adding a rail is one adapter, not a rewrite.
Today it routes payments across three live rails — x402 USDC on EVM
(Base Sepolia) and on Solana (devnet), plus MPP on Tempo (Moderato testnet) —
all behind one Paywall.gate() call. Real on-chain agent-to-agent settles are
confirmed on all three. It ships an MCP router so agents can discover + pay
endpoints, and includes a Google-AP2 inbound adapter — a signed AP2 mandate
(verified, constraint-checked + freshness-gated) settles non-custodially on the rails.
Run the demo (no wallet, no faucet, no risk)
python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
python3 run_demo.pyExpected: DEMO PASS — agent paid agent, settlement receipt issued.
What just happened (the x402 "exact-evm" loop):
buyer GET /work
-> seller 402 + PaymentRequirements {amount, asset=USDC, payTo, network}
-> buyer signs an EIP-3009 transferWithAuthorization (gasless USDC auth)
-> buyer retries with X-PAYMENT header (base64 signed payload)
-> facilitator VERIFIES the signature (real signer-recovery) + checks policy
-> facilitator SETTLES (mock: fake tx hash; live: on-chain USDC transfer)
-> seller 200 + work product + X-PAYMENT-RESPONSE receipt (tx hash)The facilitator's verify step is real cryptography even in mock mode — it recovers the EIP-712 signer and matches it to the authorization. Only the on-chain broadcast is mocked. So a passing demo proves the buyer's signing is protocol-correct against real USDC.
Related MCP server: x402 Micropayments & US City Compliance MCP
Files
file | role |
| the reusable |
| settlement receipt-ledger → |
| FastAPI agent that sells work — defines the requirements + work, wires one |
| agent that auto-pays 402s ( |
| the one crypto-subtle file: EIP-3009 typed-data, shared by buyer+facilitator so they can't drift |
| in-process verify+settle (real sig check, mock chain) — the dry-run rail |
| live x402 facilitator over HTTP via the x402 SDK's own client; |
| network/asset facts + |
| end-to-end smoke (ephemeral keys, mock facilitator) |
| live runner — settles a real x402 payment on Base Sepolia |
Go live (Base Sepolia testnet)
Two testnet wallets (buyer signs, seller receives):
python3 -c "from eth_account import Account; a=Account.create(); print('addr', a.address); print('key', a.key.hex())"Do this twice. Keep the keys out of git (use
.env).Fund the buyer with Base Sepolia testnet USDC (Circle faucet) + a little testnet ETH for any gas the facilitator relays.
.env(copy.env.example→.env, it's gitignored + auto-loaded):APV0_NETWORK=base-sepolia APV0_BUYER_PRIVATE_KEY=0x... # buyer testnet key (signs) APV0_SELLER_ADDRESS=0x... # seller address (receives) APV0_FACILITATOR_URL=https://x402.org/facilitatorRun it live:
python3 run_live.pyThe seller now uses
RealFacilitator(the x402 SDK's own facilitator client), the buyer auto-pays the 402, and x402.org broadcasts the EIP-3009 USDC transfer on-chain. You get a real tx hash →https://sepolia.basescan.org/tx/<hash>.Gasless: with EIP-3009 the facilitator relays gas, so the buyer only needs testnet USDC, not ETH.
Gate your own endpoint (the product primitive)
from router.paywall import Paywall
from router.facilitator_real import get_facilitator
paywall = Paywall(get_facilitator(), my_requirements_fn) # mock ↔ real by env
@app.get("/my-endpoint")
def my_endpoint(request: Request):
return paywall.gate(request, lambda: do_expensive_work())That one .gate() call handles the whole x402 V2 dance — 402 challenge → verify →
settle → record receipt → deliver — and appends every settlement to the
receipt-ledger. The deployer never touches the protocol or holds a key.
v1 dogfood — pay an agent, get REAL work back
v0 proved the payment. v1 proves the loop: a buyer agent pays → a seller agent
does real inference → returns the result + a settlement receipt. The seller's
_do_the_work(task) is the product's integration point (plug in your own
model/compute/service).
APV0_OPENROUTER_KEY=sk-or-... python3 run_v1_dogfood.py "your task here"→ V1 DOGFOOD PASS — agent paid agent for real work ✅ (mock payment + real model
call by default; set APV0_NETWORK=base-sepolia for a real on-chain settle under
the same loop). Without a key it returns a stub so the product still runs.
This is the authentic loop: an agent doing real work, metered + paid-for over x402 — the same primitive whether the work is a model call, a compute job, or any other billable agent task.
Available Tools
4 toolsdiscover_payment_railsA
Probe a paid endpoint and report which payment rails it accepts + the price for each — WITHOUT paying.
The neutral rail-discovery layer: one call tells your agent every way it could pay this endpoint, across whatever rails the endpoint offers. Use this before pay_for_resource to see the price/rails.
Inputs: url (required).
list_known_railsA
List EVERY agent-payment rail/protocol Interline knows about + how it relates to each — the neutral catalog.
Separates rails Interline SETTLES natively (route_mode=native-settle: x402, AP2-via-adapter) from protocols it ROUTES you TO but does not settle (route_mode=handoff: Virtuals ACP's own on-chain escrow, OpenAI/Stripe ACP's card-only delegated payment). One call = the whole agent-payment landscape, including the rails we don't move funds on. Pair with discover_payment_rails (what a specific endpoint accepts).
Inputs: no named parameters.
pay_for_resourceA
Pay for and fetch a paywalled resource, returning its content + a settlement receipt.
Routes the payment through the rail the endpoint accepts; never pays more than max_price_usdc.
Uses the caller's OWN wallet key from APV0_BUYER_PRIVATE_KEY (non-custodial — this server never
holds or sees funds). task is appended as a query param for endpoints that take one.
Inputs: url (required), task, max_price_usdc.
payment_historyC
Return the most recent cross-rail settlement receipts — the unified ledger across every rail paid through.
Inputs: limit.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 4 tools
Each tool has a clearly distinct purpose: discovering endpoint-specific rails, listing all known rails, paying for a resource, and viewing payment history. No overlap or ambiguity.
Most tools follow a verb_noun pattern (discover_, list_, pay_), but 'payment_history' is a noun_noun pair, creating a minor inconsistency. Overall clear and predictable.
Four tools cover the essential operations for a payment rail server: discovery, listing, payment, and history. The count is well-scoped and appropriate.
Core workflows are covered: rail discovery (per-endpoint and global), payment, and history. Missing potential operations like refund or cancellation, but not critical for the stated purpose.
Maintenance
Related MCP Connectors
Machine-native tools for autonomous agents with free routing and x402 USDC pay-per-call.
Pay-per-call tools for autonomous agents, settled in USDC on Base via x402.
17 pay-per-call web, finance, legal and onchain tools for AI agents. USDC on Base via x402/MPP.
Pay-per-use MCP tools for AI agents. USDC on Base via x402. No API keys.
Related MCP Servers
- FlicenseAqualityDmaintenanceEnables AI agents to call x402-gated APIs using a central credit balance, abstracting away blockchain complexity and payment proofs. It provides tools to fetch data from payment-required endpoints, check usage balances, and simulate transaction costs.658 npm2-
- AlicenseAqualityBmaintenanceLive Base mainnet (eip155:8453) x402 micropayment MCP gateway by Keith S. (kwizzlesurp.com · Sevtech · Dragon&PandaDuo). Pairs a free open-data catalog with $0.01 USDC property & rental compliance checks across 14+ US cities, Base gas/finality intelligence, and x402 buyer/seller tools. Verified on x402-trust (82.5/100, 100% uptime) & 24K Labs.5201MIT

PayAgents MCP Serverofficial
AlicenseAqualityDmaintenanceEnables AI agents to autonomously make policy-controlled payments for APIs and tools via Bitcoin Lightning (L402) and Base USDC (x402), including paying paywalled endpoints, checking balances, and reviewing transactions.321 npm1MIT- FlicenseNot gradedqualityCmaintenanceEnables AI agents to pay per tool call in USDC via the x402 micropayment protocol, with no API keys or subscriptions required.-