x402-api-directory / README.md
youraitools's picture
Add tutorial: exploring prices, networks and uptime
3c680ae verified
|
Raw History Blame Contribute Delete
16.8 kB
metadata
license: cc-by-4.0
pretty_name: x402 API Directory (prices and daily status)
language:
  - en
tags:
  - x402
  - ai-agents
  - api
  - payments
  - uptime
  - crypto
  - usdc
  - base
  - tabular
size_categories:
  - n<1K
task_categories:
  - tabular-classification
  - time-series-forecasting
configs:
  - config_name: listings
    data_files:
      - split: train
        path: data/listings.csv
    default: true
  - config_name: stats_summary
    data_files:
      - split: train
        path: data/stats_summary.csv

x402 API Directory: listings, prices and daily status (YourAITools)

An open dataset of 372 pay-per-call APIs for AI agents that use the x402 HTTP payment protocol (plus a few agent-payment protocols, labeled as such), with each listing's category, networks, tokens, listed price and how the listing was verified, joined to a daily unpaid availability check: up/down status, HTTP 402 validity, the price actually seen in the 402 payment request, 7/30-day uptime, latency, and an x402 conformance grade.

  • Live version: https://youraitools.co/status (status, uptime and price per call, updated daily)
  • Source: compiled by YourAITools from our own checks and providers' public sites
  • License: CC BY 4.0. Credit: "x402 API Directory by YourAITools (https://youraitools.co), CC BY 4.0"
  • Snapshot: see SNAPSHOT.txt (this copy: 2026-11-01; listings updated 2026-10-31)

Files

File Rows What it is
data/listings.json 372 items The directory: one object per listed API, plus categories and a changelog of delistings
data/listings.csv 372 Same listings flattened (lists joined with ; , nested objects as JSON strings)
data/stats.json 372 Full daily-check stats per listing, incl. 30 days of daily results and price history
data/stats_summary.csv 372 One flat row per listing with the most-used stats columns
data/stats.schema.json – JSON Schema for stats.json (from the publisher)
SNAPSHOT.txt – Snapshot date and source timestamps
refresh.sh, build.py – Re-pull the public sources and rebuild data/

Join key: slug (present in every file).

Field dictionary: listings (listings.json items / listings.csv)

Field Type Meaning
slug string Stable id, also the page path youraitools.co/tool/<slug>
name string Service name
url string Provider's homepage
description string What the API does (our wording)
category string One of 14 categories (categories list in listings.json), e.g. crypto-data, data-apis, trust-security
protocol string Payment protocol; x402 for 363 of 372 listings
networks list Settlement networks, e.g. Base, Solana, Polygon
tokens list Payment tokens, mostly USDC
price string Listed price per call or range, in USD
priceDetail string Extra price notes (some rows)
exampleEndpoint string A public endpoint that answers unpaid requests with an HTTP 402 payment request
endpointMethod string HTTP method for exampleEndpoint when not GET (some rows)
exampleBody object JSON body for POST endpoints (some rows)
listedIn string Where else the service is publicly listed
sources list Public URLs the listing was built from
verifiedOn date Last date we verified the listing
verification string How it was verified (unpaid 402 check, site fetch, etc.)
featured / featuredUntil bool / date Paid placement flag. Placement never changes status, uptime or trust numbers
addedOn date Date added to the directory
claimed / claimedBy / claimedOn bool / string / date Whether the provider's team claimed the listing (team name only)
ownerLinks list Links supplied by the provider, marked as owner-reported
page_url string Listing page on youraitools.co

Field dictionary: stats (stats.json listings / stats_summary.csv)

Field Meaning
status up (HTTP answer < 500 and not 404/410), down (timeout, network error, 5xx, 404, 410), stale (no check for 3 days), not_yet_measured, no_probe_target
probe_target URL, method and body the daily check uses
last_check Time, HTTP status, valid_x402, x402 version, latency, error of the latest check
price.listed / listed_usd_range Listed price and its numeric range
price.mode fixed, dynamic or prepaid
price.seen / seen_usd The USDC option in the 402 that fits the listed range (Base preferred); null otherwise
uptime.7d / uptime.30d Checks, up count, uptime_pct, valid_x402_pct
daily Last 30 UTC days: up, valid_x402, checks (null = no check)
down_since / last_status_change Start of the current down run / latest up-down flip
latency_ms_median Median latency of up checks over 7 / 30 days
grade / score x402fix conformance grade (A–F) and score from an unpaid preview
price_history / last_valid_price Changes in the seen price (date, usd, network)
trust Trust score 0–100 (uptime 40, valid 402 40, price match 10, latency 10), shown after 7 days and 6 checks; full formula in stats.schema.json
clicks_30d Listing-page clicks on youraitools.co in the last 30 UTC days
probe_hold True while our check of this listing is being fixed on our side

In stats_summary.csv these are flattened to columns such as uptime_30d_pct, valid_x402_30d_pct, price_seen_usd, trust_score.

How the data is collected

One unpaid request per listing per day to its example endpoint, User-Agent YourAITools-ListingProbe/1.0, no payment header ever, redirects not followed, 8 s timeout, no retries. No IPs or response bodies are stored. Listings are built from each provider's public site and a live unpaid 402 check.

Snapshot at a glance (2026-11-01): 339 up, 9 down, 24 without a probe target; 333 returned a valid x402 payment request on the latest check; networks: Base 357, Solana 142, Polygon 45, Arbitrum 32. Trust scores begin once listings have 7 days of checks.

Update cadence

The live directory and status pages update daily at https://youraitools.co/status (machine-readable: https://api.youraitools.co/stats/v1/listings). This published copy is a dated snapshot and is refreshed periodically (target: weekly) with ./refresh.sh. For current numbers use the live version.

Uses

Research on the x402 / agent-payments ecosystem, API availability and pricing analysis, picking reliable paid APIs for agents, time series of uptime and price.

Limitations

  • One check a day from one location; a short outage can be missed or over-weighted.
  • up means the endpoint answered, not that a paid call returns correct data. We never pay.
  • Listings are curated by YourAITools, which also runs its own x402 tools; those are not in this dataset's listings and never in rankings.
  • Not financial advice; listing is not an endorsement.

Citation

YourAITools (2026). x402 API Directory: listings, prices and daily status. https://youraitools.co/status. CC BY 4.0.

Corrections: hello@youraitools.co (public contact).

Tutorial: exploring prices, networks and uptime

Summary: A hands-on look at an open CC BY 4.0 dataset of 372 pay-per-call APIs that AI agents can pay per request over x402 (HTTP 402 + USDC). We load it with datasets, join listings to daily availability checks, and answer three practical questions: what a call actually costs by category, which networks are common, and how many APIs answered a valid payment request on the snapshot day. Every number below comes from running the code shown.


What the dataset is

youraitools/x402-api-directory is a snapshot of the directory we run at youraitools.co. Disclosure up front: we built the directory and the daily checker, and we sell some of the listed tools.

x402 is a small protocol on top of HTTP: an API answers an unpaid request with status 402 Payment Required and a JSON payment request (amount, token, network, recipient). The client pays, usually in USDC, and retries. That makes it usable by agents with a wallet and no API key. If 402 is new to you, our HTTP 402 explainer covers the request and response shapes.

The dataset has two configs, joined by slug:

  • listings (default): 372 rows. Name, category (14 categories), protocol, settlement networks, tokens, listed price, an example endpoint, and how the listing was verified.
  • stats_summary: 372 rows. Result of a daily unpaid check of each example endpoint: status, whether the 402 was valid, the price actually seen in the 402, 7/30-day uptime, median latency and a conformance grade (A–F).

This copy is dated 2026-11-01 (SNAPSHOT.txt). The live numbers change every day; the last section shows how to pull them.

Load, join and summarize

pip install datasets pandas
from datasets import load_dataset
import pandas as pd

REPO = "youraitools/x402-api-directory"
listings = load_dataset(REPO, "listings", split="train").to_pandas()
stats = load_dataset(REPO, "stats_summary", split="train").to_pandas()

# 1. Join the two tables on slug
df = listings[["slug", "name", "category", "protocol", "networks"]].merge(
    stats[["slug", "status", "last_valid_x402", "price_seen_usd",
           "uptime_30d_pct", "valid_x402_30d_pct", "latency_ms_median_30d", "grade"]],
    on="slug", how="left")
print(df.shape)

# 2. Status on the snapshot day
print(df["status"].value_counts())
print("valid 402 on latest check:", int(df["last_valid_x402"].fillna(False).astype(bool).sum()))

# 3. Price actually seen in the 402, by category
priced = df.dropna(subset=["price_seen_usd"])
by_cat = (priced.groupby("category")["price_seen_usd"]
          .agg(apis="count", median="median", p90=lambda s: s.quantile(0.9))
          .sort_values("apis", ascending=False))
print(by_cat.round(4).to_string())

# 4. Networks: one row per (API, network)
nets = df.assign(network=df["networks"].fillna("").str.split("; ")).explode("network")
nets = nets[nets["network"] != ""]
print(nets.groupby("network")
          .agg(apis=("slug", "nunique"), median_price=("price_seen_usd", "median"))
          .sort_values("apis", ascending=False).head(6).round(4).to_string())

# 5. A shortlist an agent could use: up, valid 402 every day, <= $0.01 a call
short = df[(df["status"] == "up") & (df["valid_x402_30d_pct"] == 100)
           & (df["price_seen_usd"] <= 0.01)]
print(len(short), "of", len(priced), "priced APIs")
print(short.groupby("category")
           .agg(apis=("slug", "count"),
                median_latency_ms=("latency_ms_median_30d", "median"),
                grade_A=("grade", lambda g: int((g == "A").sum())))
           .sort_values("apis", ascending=False).head(6).to_string())

Output (run Nov 9, 2026, against the 2026-11-01 snapshot):

(372, 12)
status
up                 339
no_probe_target     24
down                 9
Name: count, dtype: int64
valid 402 on latest check: 333
                  apis  median     p90
category                              
data-apis           45  0.0100  0.0160
crypto-data         37  0.0050  0.1000
trust-security      36  0.0100  0.0750
finance-data        31  0.0100  0.1000
search-web          30  0.0050  0.0500
marketplaces        28  0.0050  0.0160
dev-infra           28  0.0050  0.1000
business-data       24  0.0100  0.0528
commerce            16  0.0100  0.2600
payments            13  0.0100  0.0100
ai-inference        12  0.0075  0.9028
social-data         11  0.0140  0.0600
media-generation     7  0.0100  1.8682
          apis  median_price
network                     
Base       357        0.0100
Solana     142        0.0080
Polygon     45        0.0050
Arbitrum    32        0.0050
Arc         15        0.0060
Monad        9        0.0042
227 of 318 priced APIs
                apis  median_latency_ms  grade_A
category                                        
data-apis         38              438.0       22
trust-security    27              557.0       19
marketplaces      25              480.0       16
search-web        23              525.0       13
crypto-data       22              510.5       14
dev-infra         20              416.0       11

What the numbers say

Availability. On the snapshot day 339 of 372 APIs were up, 9 were down and 24 have no public endpoint we can check without paying. 333 returned a well-formed x402 payment request. "Up" is not the same as "payable": an API can answer with a 401 or a 400 and still count as up. If your agent picks APIs at runtime, filter on last_valid_x402, not just status.

Price per call. We use price_seen_usd (the amount in the live 402) rather than the listed price, because the two sometimes differ. 318 APIs had a seen price. The median call costs $0.005 to $0.01 in almost every category; the p90 column is where categories differ. Media generation and AI inference have long tails (p90 $1.87 and $0.90) because they include image/video and large-model calls. Data APIs and marketplaces stay tight (p90 $0.016).

Networks. Base is listed by 357 APIs, Solana by 142. Many APIs accept more than one network, so the counts overlap. The seen price is taken from one option per API (Base preferred), so the network medians are not a like-for-like comparison; don't read them as "network X is cheaper".

A runtime shortlist. Requiring "up, valid 402 on every check so far and at most $0.01 a call" keeps 227 of the 318 priced APIs. That is a reasonable starting filter for an agent that picks a tool per task; add a latency cap and a minimum grade if you need them.

Limits of this data

  • An unpaid probe is not a settled payment. We send one request per API per day with no payment header, 8 s timeout, no retries. A valid 402 shows the API asks for payment correctly. It does not prove the paid call returns good data.
  • Short history. Daily checks started on 2026-10-27, so the snapshot has at most 6 checks per API. Uptime percentages will mean more after a few weeks.
  • Coverage. Only APIs we list are checked. The directory is curated, not a crawl of every x402 server.
  • Prices move. price_seen_usd is the price on the check day. Dynamic-priced APIs (price_mode == "dynamic" in stats_summary) can quote differently per request.

Method details are on our about page. Nothing here is financial advice or a recommendation to use any listed API.

Getting today's numbers

The Hub copy is a periodic snapshot. The same daily stats are served as JSON (no key needed; send a User-Agent, as the API rejects Python's default one):

import json, urllib.request
import pandas as pd

req = urllib.request.Request("https://api.youraitools.co/stats/v1/listings",
                             headers={"User-Agent": "x402-dataset-tutorial/1.0"})
with urllib.request.urlopen(req, timeout=30) as r:
    live = json.load(r)
cur = pd.json_normalize(live["listings"])
print(live["generated_at"], len(cur))
print(cur["status"].value_counts().to_string())
print("valid 402 on latest check:", int(cur["last_check.valid_x402"].fillna(False).astype(bool).sum()))
2026-11-09T20:47:54.376Z 438
status
up                 402
no_probe_target     26
down                10
valid 402 on latest check: 391

(Run Nov 9, 2026, 3:47 PM ET. The live directory has grown to 438 listings since the snapshot.)

The live tables are browsable at youraitools.co/status. If you're building an agent that has to pick a paid API for a task, our guide on finding a paid x402 API for an agent task walks through doing it from code.

Citing and reusing

CC BY 4.0. Credit: "x402 API Directory by YourAITools (https://youraitools.co), CC BY 4.0". A DOI-versioned copy is on Zenodo: 10.5281/zenodo.23864273.


We run youraitools.co, the directory this dataset comes from, and sell some of the listed tools. Written with AI assistance; all numbers were produced by the code above and checked against the dataset on Nov 9, 2026.