How to Find Verified x402 APIs for AI Agents (Without Managing a Single API Key)

Your AI agent needs weather data. You haven't configured a weather API. The agent stops, asks you to sign up, get keys, set environment variables, restart. The autonomous magic breaks.

This keeps happening because today's agents are tool-limited. They can only use APIs you've pre-configured. We built EntRoute to make agents budget-limited instead. Give your agent a wallet and a task. It discovers and pays for whatever it needs.

The x402 Protocol (30-Second Primer)

x402 is an open protocol by Coinbase that brings HTTP 402 Payment Required back to life. An API endpoint returns a 402 with payment details in the headers. The client signs a USDC transaction, retries the request with a payment proof, and gets the response. No API keys. No OAuth. No billing portal.

The protocol is live with 500+ providers and growing. But having endpoints isn't enough. Agents need to find the right one, trust that it works, and pick the best option when there are five providers for the same capability.

That's the gap EntRoute fills.

How It Works

EntRoute is a discovery API. An agent describes what it needs, either by intent or capability ID, and gets back ranked, verified endpoints with pricing.

curl -X POST https://api.entroute.com/discover \
  -H "Content-Type: application/json" \
  -d '{"intent": "get the current price of ETH"}'

Response:

{
  "resolved": {
    "capability_id": "defi.token_price",
    "confidence": 0.95
  },
  "ranked_endpoints": [
    {
      "provider_name": "Silverback",
      "url": "https://x402.silverback.xyz/v1/token-price",
      "method": "GET",
      "score": 0.87,
      "payment": {
        "price_per_call": 0.001,
        "network": "base",
        "accepted_assets": ["USDC"]
      },
      "observed": {
        "success_rate_7d": 0.98,
        "p95_latency_ms": 150
      }
    }
  ]
}

The key fields in that response are under observed. Those aren't claimed by the provider. They're measured by us.

Why Not Just Use the Bazaar?

Coinbase's x402 Bazaar is the official registry. It's great, and we ingest from it daily. But it's a flat list. Every endpoint that registers shows up, whether it works or not.

We ran the numbers on what the Bazaar contains:

• Endpoints that don't return 402 at all
• Endpoints with invalid payment headers
• Endpoints on Solana or testnets that agents can't pay on today
• Endpoints that accept payment but return garbage data

EntRoute adds three layers on top:

1. Continuous Verification

Every endpoint gets probed every 10 minutes:

• Does it return 402 Payment Required?
• Are the x402 payment headers valid and parseable?
• What's the actual latency?
• Does it fulfill after payment? (for the 31 endpoints we've confirmed end-to-end)

Endpoints that fail get demoted. Endpoints that stay reliable rise in the rankings.

2. Quality-Based Ranking

When multiple endpoints serve the same capability, we rank them by measured signals:

Agents can also request ranking presets (reliability, speed, budget, or balanced) depending on what matters for the task.

3. Intent Resolution

Agents don't need to know capability IDs. Natural language works:

# These all resolve to the right capability
curl -d '{"intent": "translate this to French"}'
curl -d '{"intent": "what is the mass of Jupiter"}'
curl -d '{"intent": "search the web for AI news"}'

If the top capability match has no live endpoints, EntRoute falls through to the next-best match (within a tight confidence window) so the agent still gets a useful result.

Integration: Three Ways In

Option 1: MCP Server (Claude Code, Cursor, etc.)

One command:

claude mcp add entroute -- npx @entroute/mcp-server

Your agent gets three tools:

• discover_paid_api: find endpoints by intent or capability
• call_paid_api: call an endpoint with automatic x402 payment
• list_capabilities: browse all available categories

The MCP server includes sample_request and sample_response in its output so the agent sees the exact parameter format, no guessing.

Option 2: TypeScript SDK

npm install @entroute/sdk-agent-ts

import { EntRouteClient } from '@entroute/sdk-agent-ts';

const client = new EntRouteClient({
  baseUrl: 'https://api.entroute.com',
});

// Discover endpoints
const result = await client.discover({
  intent: 'get ETH token price',
  constraints: { max_price: 0.01 }
});

// Or discover + call with automatic fallback
const response = await client.discoverAndCall({
  capability_id: 'defi.token_price'
}, {
  buildRequest: (endpoint) => ({
    method: endpoint.method,
    headers: { 'Content-Type': 'application/json' }
  })
});

The SDK handles x402 v1 and v2, automatic payment signing, and fallback to the next-ranked endpoint if the first one fails.

Option 3: Raw API

# List all capabilities
curl https://api.entroute.com/capabilities

# Discover with constraints
curl -X POST https://api.entroute.com/discover \
  -H "Content-Type: application/json" \
  -d '{
    "capability_id": "web.search",
    "constraints": {
      "max_price": 0.005,
      "verified_only": true
    }
  }'

No auth required for discovery. Rate limits are generous (60 req/min anonymous, 600 authenticated).

What's in the Catalog

EntRoute currently indexes 1,000+ endpoints across 37 capabilities from 500+ providers. Categories include:

• DeFi: token prices, swap quotes, portfolio analytics, staking
• Web: search, scraping, content extraction
• Data: weather, stocks, knowledge graphs
• AI: text generation, translation, sentiment analysis, image description
• Social: Twitter/Farcaster data, social analytics
• Infrastructure: QR codes, DNS lookups, URL shortening

We sync from the Coinbase Bazaar daily and run keyword-based mapping to categorize endpoints. New endpoints are automatically queued for 402 verification.

Browse the full catalog: entroute.com/capabilities

The Honest Parts

A few things we're upfront about:

Fulfillment verification is still early. We've confirmed end-to-end payment-to-data for 31 endpoints across 7 capabilities. The rest are 402-verified (they return the right headers) but we haven't confirmed they deliver good data after payment. This is the active frontier.

The x402 ecosystem is young. Many endpoints are flaky, some are outright broken, and a non-trivial number accept payment but return errors. That's exactly why we think the verification layer matters, but it also means agent builders should set expectations.

We filter out unpayable endpoints. Solana, Tron, and testnet endpoints are excluded from discovery results because most agents can't pay on those networks today.

Try It

The fastest way to see if EntRoute is useful for your agent:

# See what's available
curl https://api.entroute.com/capabilities | jq '.capabilities | length'

# Try a discovery query
curl -X POST https://api.entroute.com/discover \
  -H "Content-Type: application/json" \
  -d '{"intent": "search the web"}' | jq '.ranked_endpoints[0]'

# Install the MCP server
claude mcp add entroute -- npx @entroute/mcp-server

• Site: entroute.com
• Docs: entroute.com/docs/quickstart
• SDK: npm install @entroute/sdk-agent-ts
• Stats dashboard: entroute.com/stats

We're looking for agent builders to try the integration and API providers who want to monetize without building billing infrastructure. If you have an API and want to list it, the provider guide walks through the process.

EntRoute is open-source and free to query. Built on Cloudflare Workers, D1, and SvelteKit.