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 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-
- AlicenseNot gradedqualityBmaintenanceEnables AI agents to discover, pay for, and sell HTTP APIs using the x402 micropayment protocol, with USDC settlement on Base mainnet. Includes tools for payment requirements, paying and fetching resources, building seller configurations, and monitoring revenue.242 npm1MIT

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.-