Today we're launching the first pay-per-call CryptoPunk valuation API built for autonomous agents. Any agent with a funded wallet can get a fair-value estimate in a single HTTP call — no API key, no subscription, no human in the loop.

Why agents need price anchors

Autonomous agents are beginning to trade, bid, and lend against NFTs. But they face a bootstrapping problem: how do you value a CryptoPunk programmatically?

Floor price is a blunt instrument — it tells you the cheapest listed Punk, not what your Punk is worth. Trait-based heuristics miss the nonlinear interactions between attributes (a Beanie + VR combo isn't just the sum of its parts). And appraisal services designed for humans require API keys, subscriptions, and manual integration.

We built PunkPredictor's agent API so that any agent can answer the question "What is CryptoPunk #N worth right now?" with a single HTTP request and an on-chain USDC payment.

How x402 works

The API uses x402, an open payment protocol that turns HTTP 402 ("Payment Required") into a real, machine-readable payment flow:

1. Request — Your agent calls the endpoint. The server responds with 402 and a payment-required header containing the price, token, and payee address.
2. Sign — Your x402 client signs a USDC transfer on Base mainnet and retries the request with a payment-response header.
3. Settle & Respond — The server verifies the payment, settles on-chain, and returns the valuation data in the same HTTP response.

No API keys. No OAuth. No subscription tiers. Just a funded wallet and a standard HTTP client with x402 support.

The endpoints

The fair-price endpoint is the simplest entry point — send a Punk ID, get a fair-value estimate in ETH. The fair-price-plus endpoint adds the full probability distribution, an uncertainty score, and confidence intervals for agents that need to reason about risk.

The top-delayed and top-realtime endpoints return the most undervalued currently-listed Punks — perfect for agents scanning for buying opportunities.

Example: getting a fair-price estimate

import os, requests
from eth_account import Account
from x402.client import x402ClientSync
from x402.http.clients.requests import wrapRequestsWithPayment
from x402.mechanisms.evm.signers import EthAccountSigner
from x402.mechanisms.evm.exact.client import ExactEvmScheme

account = Account.from_key(os.environ["EVM_PRIVATE_KEY"])
client  = x402ClientSync()
client.register("eip155:8453", ExactEvmScheme(EthAccountSigner(account)))
session = wrapRequestsWithPayment(requests.Session(), client)

r = session.post(
    "https://api.punkpredictor.xyz/agents/v2/fair-price",
    json={"id_punk": 9999},
    timeout=90,
)
print(r.json())
# {"id_punk": 9999, "fair_price_eth": 31.77, ...}

Proof: first mainnet settlement

This isn't a testnet demo. The API is live on Base mainnet and has already settled its first real USDC payment. Here's the receipt:

Field	Value
Settlement tx	0x9b8a...bfab
Block	42074914
Amount	5.00 USDC
Payer	0x760D...9554
Payee	punkpredictor.eth (0x4f6e...6062)
Endpoint	POST /agents/v2/fair-price
Response	Punk #9999 → 31.77 ETH fair value

What this means for the agent economy

We believe the future of API commerce is pay-per-call. Agents don't fill out sign-up forms. They don't manage subscription renewals. They evaluate resources, pay for what they need, and move on.

x402 makes this possible at the protocol level. PunkPredictor is one of the first production APIs to adopt it, and we think this model will become the default for agent-to-service interactions.

If you're building an agent that needs CryptoPunk valuations — whether for trading, lending, portfolio management, or analytics — the API is live and ready.