x4x.c00l.site
5 services · 24 paid endpoints · live on Base mainnet

Pay-per-call APIs
built for AI agents.

Five HTTP APIs an autonomous agent can discover, price and pay for entirely on its own — no account, no API key, no dashboard, no human in the loop. One request returns 402 with the price attached; your client signs a USDC authorisation and retries. Settlement takes about a second.

Browse the catalogue /index.json Try one free →
Live readable· dataforge· netintel· aisearch· structura· /status
What is x402

An HTTP status code that finally does something.

402 Payment Required has sat unused in the HTTP spec since 1997; x402 is the open protocol that gives it a meaning — a server answers 402 with machine-readable payment terms, and the client pays and retries automatically. Because the terms are structured data rather than a checkout page, software can complete the whole exchange with no human present, which is exactly what an autonomous agent needs and exactly what a card payment cannot do.

1

Call the endpoint

An ordinary HTTP request. Nothing special, no auth header, no key. You get back 402 with a payment-required header: base64 JSON naming the exact amount, token, chain and recipient.

402 Payment Required
2

Sign, don't spend

Your client signs an EIP-3009 transfer authorisation for that amount. It is an off-chain signature: no gas, no pending transaction, no wallet popup, and nothing moves unless the call succeeds.

EIP-3009 · off-chain
3

Retry and get the data

The same request again, plus a payment-signature header. The facilitator settles on Base, we return 200 with your data and a payment-response receipt naming the transaction.

200 OK + receipt
the exchange, on the wire
$ curl -i https://readable.x.c00l.site/unfurl \
    -H 'content-type: application/json' \
    -d '{"url":"https://x.c00l.site"}'

HTTP/2 402 Payment Required
payment-required: eyJ4NDAyVmVyc2lvbiI6MiwiZXJyb3IiOiJQYXltZW50IHJl…

  # base64-decoded, this is the challenge:
  { "x402Version": 2,
    "accepts": [{ "scheme": "exact",
                  "network": "eip155:8453",     # Base mainnet
                  "amount": "1000",             # 0.001 USDC, 6dp
                  "asset": "0x8335…2913",        # USDC
                  "payTo": "0x49db…5c82" }] }

$ # your x402 client signs an EIP-3009 authorisation — off-chain,
$ # no gas, no wallet popup — and replays the same request:

$ curl -i … -H 'payment-signature: eyJ4NDAyVmVyc2lvbiI6Miwi…'

HTTP/2 200 OK
payment-response: eyJzdWNjZXNzIjp0cnVlLCJ0cmFuc2FjdGlvbiI6IjB4…
{"title": "x.c00l.site", "description": "Pay-per-call APIs…"}

You cannot be overcharged

The amount is fixed in the challenge you signed. It is not a spending allowance, not a subscription and not a card on file — it authorises one transfer of one amount, once.

You never pay for failures

Settlement only runs on a 2xx. Any 4xx or 5xx — bad input, a dead upstream, a model that could not produce conforming output — skips settlement entirely. Retries are free.

The price is legible first

An agent reads the amount before committing, and can decline. Every price is also in /index.json ahead of time, so a planner can budget a whole workflow without making a single call.

The catalogue

5 services, 24 paid endpoints.

Every one is live on Base mainnet right now. Prices below are the real amounts served in the 402 challenge, in USDC. Two endpoints price per item, so a batch is one signature and one predictable total.

readable

readable.x.c00l.site

Any URL to clean, LLM-ready Markdown

Fetches a page, strips nav, ads, cookie banners, comments and sidebars with a Readability-style density heuristic, then emits Markdown with correct headings, nested lists, GFM tables, fenced code and absolute links. The pre-processing step for RAG indexing and summarisation.

markdownscrapingragweb
POST GET/extract
Page to Markdown
$0.004
Fetch a URL, strip boilerplate, return the article body as Markdown (or text/HTML) plus title, byline, publish date, site name, language, excerpt, word count and reading time.
POST GET/unfurl
Link-preview metadata
$0.001
Head-only metadata for a URL: title, description, OpenGraph image, favicon, canonical, site name, type, theme colour, author, date, feeds and oEmbed endpoints. Cheapest call in the catalogue.
POST GET/links
Every link on a page
$0.002
Every anchor on the page, absolutised, tracking parameters stripped, deduplicated, and classified internal/external/nofollow with its anchor text and page region (nav, main, footer).
POST/batch
Extract up to 20 URLs at once
$0.003 / URL
Concurrent /extract across 1-20 URLs. Charged $0.003 x urls.length, so the amount is derivable from the request before you pay and one signature covers the whole batch. Each result carries its own ok/error.
try readable/extract
curl -s https://readable.x.c00l.site/extract \
  -H 'content-type: application/json' \
  -d '{"url":"https://en.wikipedia.org/wiki/Markdown","format":"markdown"}'
free:GET /GET /healthGET /openapi.json

dataforge

dataforge.x.c00l.site

Deterministic data conversion, query, schema and diff

Nine formats in, nine out — CSV, TSV, JSON, JSONL, YAML, TOML, XML, INI, Java properties — with RFC 4180 CSV, YAML anchors, TOML v1.0.0 and XML attributes/CDATA handled properly. Plus JSONPath querying, JSON Schema 2020-12 inference and validation, a declarative transform pipeline and RFC 6902 diff/patch. No model in the loop, so it is exact and repeatable.

datacsvyamljson-schema
POST/convert
Convert between formats
$0.002
Convert a document between any two of json, jsonl, csv, tsv, yaml, toml, xml, ini and properties. Handles quoted CSV fields with embedded commas/newlines, BOMs, CRLF and ragged rows.
POST/query
JSONPath / JSON Pointer query
$0.002
Query any supported format with JSONPath — recursive descent, unions, slices, negative indices, filter expressions — or with an RFC 6901 JSON Pointer. Output in any format.
POST/schema
Infer or validate a JSON Schema
$0.003
Without `validate`, infers a draft 2020-12 schema: array elements merged, a property marked required only when present in every sample, enums when a field has few repeated values, formats detected. With `validate`, checks the document and returns per-pointer errors.
POST/transform
Declarative transform pipeline
$0.003
Reshape tabular or nested data with an ordered pipeline: select, drop, rename, filter, compute, cast, sort, groupBy, flatten, unflatten, pivot, unpivot, dedupe, limit, offset. Read CSV, group and pivot it, write YAML, in one call.
POST/diff
Structural diff, as RFC 6902
$0.002
Diff two documents of any supported format and get a JSON Patch that turns `a` into `b`, plus a human-readable summary and per-op counts. Arrays are diffed with an LCS, so a single insertion produces one add rather than a cascade of replaces.
POST/patch
Apply an RFC 6902 patch
$0.002
Apply add, remove, replace, move, copy and test operations in order with strict pointer resolution. A failure names the operation index and the reason. Output in any format.
try dataforge/convert
curl -s https://dataforge.x.c00l.site/convert \
  -H 'content-type: application/json' \
  -d '{"data":"name,age\nada,36","from":"csv","to":"json"}'
free:GET /GET /healthGET /openapi.jsonGET /formatsPOST /detect

netintel

netintel.x.c00l.site

DNS, email deliverability, TLS and IP intelligence

Network reconnaissance from inside the Cloudflare edge: DNS-over-HTTPS against eleven public resolvers, a raw TLS handshake over TCP sockets that can read certificates a normal HTTPS client refuses to look at (expired, self-signed, wrong host), and edge metadata. If a lookup fails the field is null and warnings[] says why — never a plausible guess.

dnstlsemailasn
POST/dns
DNS lookup with DNSSEC + cross-check
$0.002
Resolve up to 12 record types at once, report DNSSEC validation status, and cross-check the answer against a second independent resolver so a poisoned or stale answer is visible.
POST/email
Email deliverability audit
$0.003
Audit an address or its domain without sending anything: MX records, SPF policy and lookup-count budget, DMARC policy and alignment, DKIM selector discovery, disposable and role-account detection, and syntax validity.
POST/tls
TLS certificate + security-header grade
$0.004
Raw TLS handshake over a TCP socket, so it reads expired, self-signed and wrong-host certificates that a normal client refuses. Returns the chain, validity window, SANs, signature algorithm, negotiated versions, plus HSTS/CSP/X-Frame security headers, graded A-F.
POST/ip
IP / CIDR / hostname intelligence
$0.002
Geolocation, ASN and AS organisation, reverse DNS, network class (datacenter, residential, Tor, cloud provider) and DNS blocklist status for an IPv4, IPv6, CIDR block or hostname.
POST/propagation
DNS propagation across resolvers
$0.005
Query one record across many public resolvers concurrently and report which ones agree. The call to make after a DNS change, to see how far it has actually spread.
try netintel/dns
curl -s https://netintel.x.c00l.site/dns \
  -H 'content-type: application/json' \
  -d '{"name":"cloudflare.com","types":["A","MX","TXT"]}'
free:GET /GET /healthGET /openapi.jsonGET /whoami

aisearch

aisearch.x.c00l.site

Web search with citations that cannot be invented

Every endpoint returns Markdown with inline [n] markers plus a citations[] array. The markers are rendered from the search API's own source attribution rather than written by the model, so a fabricated citation is structurally impossible. Returns an explicit "could not find a reliable source" instead of guessing.

searchcitationsresearchai
POST/answer
Fast cited factual answer
$0.008
Single-shot factual lookup: one short cited paragraph, no report structure. The cheap call for grounding a single fact. Flags a false premise in the question rather than answering it, and says so plainly when no reliable source exists.
POST/search
Cited search with synthesised answer
$0.02
Searches the web and returns a cited Markdown answer, the citation list, the raw result set and follow-up questions. depth=standard additionally searches for evidence against the working answer before committing to it.
POST/compare
Researched side-by-side comparison
$0.03
Researches 2-6 subjects independently, then returns a verdict, a Markdown comparison table, the differences that would actually change a decision, caveats, and the same data as a structured JSON matrix you can sort and filter.
POST/research
Agentic deep research report
$0.25
Multi-step agentic investigation: plans sub-questions, searches each, opens and reads promising pages with an SSRF-hardened reader, identifies its own gaps, searches for counter-evidence, then writes a cited report. Minutes, not seconds. The most expensive call in the catalogue and the only one priced above $0.05.
try aisearch/answer
curl -s https://aisearch.x.c00l.site/answer \
  -H 'content-type: application/json' \
  -d '{"query":"What is the current block time on Base?"}'
free:GET /GET /healthGET /openapi.json

structura

structura.x.c00l.site

Any source plus your JSON Schema, out comes conforming JSON

Give it a URL, raw HTML, plain text or a document blob and a JSON Schema; the output is validated against your exact schema locally before it is returned. If the model's first attempt does not conform, the per-pointer errors are fed back and it repairs; if it still fails after the attempt cap you get a 5xx and are not charged. Non-conforming data is never returned as a success, and an absent value comes back null rather than invented.

extractionjson-schemallmstructured
POST/extract
Extract into your schema
$0.015
Source plus JSON Schema in, conformant JSON out, validated before the response is built. Every response carries per-field confidence and an absent[] list of what the source did not contain.
POST/infer
Infer a schema and fill it
$0.02
For "just structure this for me". No schema from you: it identifies what the document is, designs the schema a competent engineer would have written, then extracts into it and returns both the schema and the data.
POST/table
Extract every table
$0.012
All tabular data in the document as clean arrays of objects, with detected headers, per-column types and units, and RFC 4180 CSV alongside the JSON. Merged and multi-row headers are resolved.
POST/batch
One schema across many sources
$0.012 / source
Apply one schema to up to 15 sources. The total is computed from the item count, so the 402 challenge already states the exact amount and one signature covers the batch. Each item reports its own success independently.
POST/classify
Classify text against your labels
$0.006
Every label is scored 0-1, not just the winner, so you can threshold it yourself and see how close the call was via `margin`. The label set is baked into the model constraint, so an off-list label cannot come back. Supports multi-label.
try structura/extract
curl -s https://structura.x.c00l.site/extract \
  -H 'content-type: application/json' \
  -d '{
       "source": {
         "url": "https://example.com/product"
       },
       "schema": {
         "type": "object",
         "properties": {
           "name": {
             "type": [
               "string",
               "null"
             ]
           },
           "price": {
             "type": [
               "number",
               "null"
             ]
           }
         }
       }
     }'
free:GET /GET /healthGET /openapi.jsonGET /limitsPOST /validate
No risk

Try it without paying anything.

Every service exposes its documentation, health probe and full OpenAPI spec for free, and three of them do real work for free. netintel /whoami is the best first call: it returns everything the edge can see about your own connection, and it costs nothing.

free — no payment, no signup, works right now
# curl -s https://netintel.x.c00l.site/whoami | jq
# curl -s https://dataforge.x.c00l.site/formats | jq
# curl -s -X POST https://dataforge.x.c00l.site/detect -d '{"data":"a,b\n1,2"}'
# curl -s https://structura.x.c00l.site/limits | jq
# curl -s https://x.c00l.site/status | jq
EndpointWhat you get, for nothing
GET readable/health Liveness probe
GET readable/openapi.json OpenAPI 3.1 spec
GET dataforge/health Liveness probe
GET dataforge/openapi.json OpenAPI 3.1 spec
GET dataforge/formats Supported formats, transform ops and hard limits
POST dataforge/detect Sniff the format of a document
GET netintel/health Liveness probe
GET netintel/openapi.json OpenAPI 3.1 spec
GET netintel/whoami Your IP, geo, ASN, TLS version and cipher, HTTP protocol, Cloudflare colo and TCP RTT start here
GET aisearch/health Liveness probe
GET aisearch/openapi.json OpenAPI 3.1 spec
GET structura/health Liveness probe
GET structura/openapi.json OpenAPI 3.1 spec
GET structura/limits Machine-readable limits and prices
POST structura/validate Dry-run: check a JSON Schema is usable, free
Client code

Wrap fetch once. Then forget payments exist.

The reference client turns the whole protocol into a drop-in replacement for fetch. Below is a complete, runnable program — the same pay() handles every endpoint in this catalogue.

node — @x402/fetch + viem
// npm i @x402/fetch @x402/evm viem   —   verified against these exact packages
import { wrapFetchWithPaymentFromConfig } from "@x402/fetch";
import { ExactEvmScheme } from "@x402/evm/exact/client";
import { privateKeyToAccount } from "viem/accounts";

// A funded Base-mainnet account holding USDC. It needs no ETH: the
// facilitator submits the transfer and pays the gas.
const account = privateKeyToAccount(process.env.PRIVATE_KEY);

// One wrapped fetch pays for every endpoint in this catalogue.
const pay = wrapFetchWithPaymentFromConfig(fetch, {
  schemes: [{ network: "eip155:*", client: new ExactEvmScheme(account) }],
});

// Now just… fetch. The 402, the signature and the retry are invisible.
const res = await pay("https://readable.x.c00l.site/extract", {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({ url: "https://en.wikipedia.org/wiki/Markdown" }),
});

const { title, content } = await res.json();
console.log(title, content.slice(0, 400));

// Settlement proof, if you want to reconcile it:
console.log(res.headers.get("payment-response"));  // base64 { success, transaction }
python — no SDK, the raw protocol
# No SDK? The whole protocol is three HTTP facts.
# 1. Unpaid request  -> 402 + base64 JSON in the 'payment-required' header.
# 2. Sign accepts[0] -> EIP-3009 TransferWithAuthorization over the USDC domain.
# 3. Replay the identical request with a 'payment-signature' header.

import base64, json, requests

r = requests.post("https://netintel.x.c00l.site/dns", json={"name": "example.com"})
challenge = json.loads(base64.b64decode(r.headers["payment-required"]))

terms = challenge["accepts"][0]
print(terms["amount"], terms["asset"], terms["network"])
# -> 2000 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 eip155:8453

# The price is machine-readable *before* you commit. An agent can decide
# whether the answer is worth 0.002 USDC and simply walk away if not.
Paying

USDC on Base. That is the entire billing system.

There is no invoice, no plan, no minimum, no expiry and nothing to cancel. Fund an address with USDC on Base and it can call anything here until the balance runs out.

Payment parameters

Identical across all 5 services, so one client configuration covers everything.

protocolx402 v2
schemeexact
networkeip155:8453 (Base mainnet)
asset0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913
tokenUSDC, 6 decimals
signatureEIP-3009 TransferWithAuthorization
facilitatorhttps://facilitator.payai.network

What you do not need

Everything below is deliberately absent, because every one of them is a thing an autonomous agent cannot do by itself.

  • An account, an email address or a password
  • An API key to provision, rotate or leak
  • A credit card, a billing address or a VAT number
  • ETH for gas — the facilitator covers it
  • A quota request, a sales call or an approval queue

Costs, concretely

A thousand link previews is $1. A thousand pages converted to Markdown is $4. A thousand DNS audits is $2. A thousand schema-conformant extractions is $15. The only call above five cents is aisearch/research at $0.25, which runs a multi-step agent loop and reads pages, so it costs us real money too.

For agents

Machine-readable, on purpose.

If you are an LLM, a crawler or a routing layer, do not parse this page. Four documents describe the whole estate precisely, and all four are free, uncached-by-auth and CORS-open.

/index.json

The complete catalogue: every service, every endpoint, its method, absolute URL, price as both a USD string and USDC atomic units, required and optional fields with types, a working example body, a description of the response, and the full x402 payment block. Designed so a planner can cost a workflow before executing it.

/llms.txt

The same catalogue as concise Markdown, following the llms.txt convention. Small enough to drop straight into a context window as a tool manifest.

/openapi.json

One merged OpenAPI 3.1 document covering all 5 services, tagged per service with per-operation servers, so a single generated client reaches every endpoint. Each operation carries an x-402 extension with its price.

/status

A live concurrent health check of all 5 backends with per-service latency. Useful for deciding whether to route a call now or fall back. Never cached.

Discovery via the x402 Bazaar

Every paid endpoint here declares the x402 bazaar extension, so it is indexed for agents browsing the Coinbase Developer Platform discovery API with its input schema, a working example and a description written for a model deciding whether to call it. You do not have to have found this page to find these tools.