DEV Community: devtoship

We Catalogued 14,085 x402 Endpoints. 10,508 Came From One Domain.

devtoship — Thu, 23 Jul 2026 20:38:51 +0000

We index every x402 endpoint we can find and probe each one every 10 minutes. As of July 2026 the catalogue holds 14,085 endpoints.

10,508 of them belong to a single provider. All suspended. One domain mass-registered a five-figure pile of endpoints into the public registry, and if you render a registry as a directory without checking anything, that one domain is most of your "ecosystem."

Strip it out and you're left with 3,577 genuine endpoints. Of those, 2,131 pass verification and 1,446 don't — roughly two in five fail. That's the real shape of x402 today, and it's why we probe instead of list.

Here's how the verification works and what it turns up.

Why Verification Matters More Here Than Elsewhere

In a normal API marketplace you sign up, get a key, hit the endpoint. If it's broken you find out during integration and pick another.

x402 inverts that. Your agent discovers an endpoint at runtime, signs a USDC transaction, and pays before it knows whether the response is useful. If the endpoint is dead or misconfigured, the money is gone — and worse, the agent may quietly use bad data downstream.

Nobody is going to hand-check these. The catalogue has to do it continuously, and it has to demote things that stop working.

What the Handshake Probe Checks

Every 10 minutes, via a Cloudflare Cron trigger, each endpoint gets an unauthenticated request. The probe records:

Does it respond at all? Network errors, timeouts and 5xx count as failures.
Does it return 402 Payment Required? Anything else — 200, 401, 404 — means it isn't actually x402, whatever the registry says.
Is the payment challenge well-formed? We parse the x402 challenge (both v1 and v2) and require the fields that matter: price, network, recipient address, accepted assets.
Does the live price match the registered price? The probe stores the observed price alongside the registered one and flags drift.
How slow is it? Latency is recorded for ranking.

Each run writes a row to a verifications table. From the last 7 days of rows we recompute rolling success rate, p95 latency and a stability score. An endpoint whose success_rate_7d falls below 0.5 drops out of ranked_endpoints into fallback_endpoints with an explicit exclusion reason, so an agent can decide for itself whether to retry.

In the last 24 hours that came to 2,884 probes: 2,837 passed, 47 failed. A 98% pass rate sounds too good until you remember what it's measuring — these are the endpoints that already survived. The failures were mostly timeouts. Price mismatches over the last 7 days: zero. The filtering already happened; continuous probing is what keeps it accurate as things rot.

Networks Nobody Can Pay On

A quieter failure mode: endpoints registered on networks agents can't actually transact on today.

Of the full catalogue, 13,919 endpoints are on Base mainnet. The remainder scatter across 128 testnet endpoints (base-sepolia and eip155:84532), 30 on Solana, 5 on Polygon, 2 on Algorand, 1 on Arbitrum.

Testnet endpoints are the interesting case. They return a perfectly valid 402. They handshake cleanly. They will also never move real money, so surfacing them to an agent with a funded wallet is worse than useless. They stay in the catalogue but are filtered out of discovery results.

What an Agent Actually Sees

The verification work shows up directly in the /discover response:

{
  "ranked_endpoints": [
    {
      "endpoint_id": "ba98c32b-5ced-4abd-9d1f-4352085a4b53",
      "provider_name": "Rag",
      "url": "https://rag.gedx402.com/v1/aisearch/:id/query",
      "method": "POST",
      "score": 0.996,
      "score_breakdown": {
        "success_rate": 1,
        "latency": 0.992,
        "price": 0.99,
        "stability": 1
      },
      "payment": {
        "type": "x402",
        "price_per_call": 0.001,
        "network": "base",
        "accepted_assets": ["USDC"]
      },
      "observed": {
        "success_rate_7d": 1,
        "success_rate_30d": 1,
        "p95_latency_ms": 16,
        "last_verified_at": "2026-07-23 13:40:43"
      }
    }
  ]
}

That's a real response, pulled while writing this. The observed block is measured, not claimed by the provider — last_verified_at is a timestamp from an actual probe, and success_rate_7d comes from counting rows.

The Part We Haven't Solved

Handshake probes catch endpoints that are dead, fake, or malformed. They cannot catch the failure that costs you money: an endpoint that returns a clean 402, accepts payment, and then hands back an empty array, an HTML error page, or a JSON error wrapped in a 200.

Proving that requires actually paying — a real transaction, then a capability-aware check that the response contains what a caller of web.search or defi.token_price would need. We've built that machinery, with per-request caps and a daily budget, but it isn't running as a continuous sweep right now, so we don't badge endpoints with it. Claiming a verification tier you aren't currently running is exactly the kind of thing this post is arguing against.

So: what we assert is what we measure. Every endpoint in ranked_endpoints returned a valid 402 with a well-formed challenge on a payable network, recently, repeatedly. Post-payment quality is the next problem, and it's a harder one.

Try It

curl -X POST https://api.entroute.com/discover \
  -H "Content-Type: application/json" \
  -d '{
    "intent": "search the web",
    "constraints": { "verified_only": true }
  }'

Site: entroute.com
How verification works: entroute.com/docs/verification
MCP install: claude mcp add entroute -- npx @entroute/mcp-server
SDK: npm install @entroute/sdk-agent-ts

If you run an x402 endpoint and it's failing our probes, the fastest fix is usually the payment challenge — missing network or recipient address is the single most common malformation we see. Submit it and it'll be re-probed within 10 minutes.

Counts in this post were measured on 23 July 2026 and will drift. EntRoute is free to query and runs on Cloudflare Workers + D1.

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

devtoship — Fri, 17 Apr 2026 20:23:04 +0000

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:

Signal	Default Weight
Success rate (7d)	45%
Latency (p95)	25%
Price per call	20%
Stability (uptime variance)	10%

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.