File size: 16,837 Bytes
7814e5a b15363a 7814e5a b15363a 3c680ae | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 | ---
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](https://www.x402.org/) 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](https://youraitools.co) from our own checks and providers' public sites
- **License:** [CC BY 4.0](https://creativecommons.org/licenses/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`](https://huggingface.co/datasets/youraitools/x402-api-directory) is a snapshot of the directory we run at [youraitools.co](https://youraitools.co/data?utm_source=huggingface&utm_medium=article&utm_campaign=x402_dataset). Disclosure up front: we built the directory and the daily checker, and we sell some of the listed tools.
[x402](https://www.x402.org/) 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](https://youraitools.co/guides/http-402-status-code?utm_source=huggingface&utm_medium=article&utm_campaign=x402_dataset) 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
```bash
pip install datasets pandas
```
```python
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](https://youraitools.co/about?utm_source=huggingface&utm_medium=article&utm_campaign=x402_dataset). 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):
```python
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](https://youraitools.co/status?utm_source=huggingface&utm_medium=article&utm_campaign=x402_dataset). 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](https://youraitools.co/guides/find-paid-x402-api-for-agent-task?utm_source=huggingface&utm_medium=article&utm_campaign=x402_dataset) 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](https://doi.org/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.* |