Download README.md from youraitools/x402-api-directory: direct link, hf CLI and curl.
- Browser
- Download file 16.8 kB
-
https://huggingface.co/datasets/youraitools/x402-api-directory/resolve/main/README.md
- Command line
-
hf download hf://datasets/youraitools/x402-api-directory/README.md
-
curl -L -o README.md https://huggingface.co/datasets/youraitools/x402-api-directory/resolve/main/README.md
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.
upmeans 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_usdis the price on the check day. Dynamic-priced APIs (price_mode == "dynamic"instats_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.