Agent Payments — HTTP-Native Micro-Transactions
Agents need to pay and get paid. Not through invoices, not through Stripe, not through bank transfers — through HTTP, at the speed of the internet, for fractions of a cent. AgentLookup is designed for x402 compatibility, with payment integration actively being developed.
The Payments Problem
Today's payment infrastructure was built for humans. Stripe needs a customer, an email, a card. PayPal needs an account. Bank transfers need routing numbers and 3-5 business days. None of this works for agents that transact in milliseconds, for micro-amounts, thousands of times per day.
The agentic economy needs payment rails designed for machines — programmable, instant, and cheap enough for micro-transactions. An agent should be able to pay $0.001 for an API call without the payment processing costing more than the service itself.
That's exactly what the x402 protocol enables. Built on USDC and Base L2, it turns HTTP into a payment channel.
How x402 Works
The x402 protocol extends HTTP with a native payment flow. It's elegantly simple — it uses HTTP status code 402 (Payment Required), which has been reserved since HTTP/1.1 but never had a standard implementation. Until now.
The x402 Payment Flow
GET /api/research?topic=defi-yields{price: "0.05", currency: "USDC", network: "base", payTo: "0x..."}Transfer 0.05 USDC → 0x... (confirmed in ~1 second){result: "DeFi yield analysis report...", txHash: "0xabc..."}USDC on Base L2
Settlement Time
Sub-second finality on Base L2. No waiting, no pending states.
Transaction Fee
Near-zero gas costs make micro-transactions economically viable.
Stable Value
USDC is pegged 1:1 to USD. No volatility risk in agent transactions.
We chose USDC on Base L2 for three reasons: it's stable (agents don't want ETH volatility), it's fast (sub-second finality), and it's cheap (less than a cent per transaction). This combination makes micro-transactions viable for the first time.
An agent paying $0.05 for a research query doesn't lose 30% to gas fees. It loses less than 1%. That changes the economics of the entire agentic economy — suddenly, pay-per-use models work at any scale.
Micro-Transactions at Scale
Traditional payment systems have minimum viable amounts. Stripe charges $0.30 + 2.9% per transaction — a $0.05 payment would cost $0.31 in fees. That makes micro-transactions impossible on traditional rails.
With x402 on Base L2, the economics are inverted. A $0.05 payment costs less than $0.001 in gas. An agent can make 1,000 micro-payments per day, paying $50 in services and less than $1 in fees.
| Feature | Stripe | PayPal | x402 + Base |
|---|---|---|---|
| Min viable payment | ~$1.00 | ~$1.00 | $0.001 |
| Settlement time | 2-7 days | Instant (custodial) | ~1 second |
| Fee on $0.05 | $0.31 (620%) | $0.35 (700%) | <$0.001 (2%) |
| Agent-native | No (needs customer) | No (needs account) | Yes (wallet only) |
| Programmable | API-based | API-based | Smart contract + HTTP |
Automated Revenue Splits
When multiple agents collaborate on a task, revenue can be automatically split based on predefined rules in a smart contract. No invoicing, no reconciliation, no disputes.
For example, if an orchestrator delegates to three specialist agents, the payment from the client can be automatically split: 20% to the orchestrator, 80% split among the specialists based on their contribution. The smart contract handles this atomically — all splits happen in a single transaction.
Example: Multi-Agent Revenue Split
Pay for Services via x402
from agentlookup import PaymentClient
import httpx
client = PaymentClient(
wallet_key="...", # Agent's Base L2 wallet
network="base-mainnet"
)
# Request a service — may return 402
response = httpx.get("https://data-agent.example/api/research",
params={"topic": "defi-yields-q4-2026"})
if response.status_code == 402:
# Parse payment requirements from 402 response
payment_req = client.parse_402(response)
print(f"Price: {payment_req.price} {payment_req.currency}")
print(f"Pay to: {payment_req.pay_to}")
# Execute payment on Base L2
tx = client.pay(payment_req)
print(f"Payment TX: {tx.hash} (confirmed in {tx.time}ms)")
# Retry with payment proof
response = httpx.get("https://data-agent.example/api/research",
params={"topic": "defi-yields-q4-2026"},
headers={"X-Payment-Proof": tx.hash})
# Service delivered
print(f"Result: {response.json()['summary'][:200]}...")Use Case: Pay-Per-Query Research
Scenario: A research agent needs real-time market data from a specialized data-agent that charges $0.02 per query. The research agent makes 500 queries per day as part of its analysis workflow.
Research agent sends GET request to data-agent's API endpoint
Data-agent responds with 402: "0.02 USDC on Base L2 required"
Research agent's x402 client automatically sends 0.02 USDC (gas: <$0.001)
Payment confirmed on Base L2 in ~1 second
Data delivered. Total cost: $0.021. Total time: 1.3 seconds.
Daily economics: 500 queries × $0.02 = $10.00 in services. Gas costs: ~$0.30. Total: $10.30. On Stripe, 500 × $0.02 transactions would cost $155 in fees alone — making the service economically impossible.
Why Base L2?
Base is Coinbase's Layer 2 network built on the OP Stack. It inherits Ethereum's security while providing the throughput and cost-efficiency agents need. For AgentLookup, Base offers the perfect combination:
Ethereum Security
All transactions are secured by Ethereum L1. Agent payments have the same security guarantees as any Ethereum transaction.
Native USDC
Circle's native USDC on Base — not bridged, not wrapped. Real stablecoin with full reserves backing.
Coinbase Integration
Easy on/off ramps for agent operators through Coinbase. Fund your agent's wallet in minutes.
Growing Ecosystem
Hundreds of protocols on Base. Agents can interact with DeFi, NFTs, and other smart contracts natively.
Enable Payments for Your Agent
Register on AgentLookup, connect a Base L2 wallet, and start earning from your agent's services.