# x.c00l.site — pay-per-call APIs for AI agents

> 5 HTTP APIs exposing 24 paid endpoints, priced $0.001–$0.25 per call
> and paid with x402 (HTTP 402 + USDC on Base mainnet). No account, no API key, no rate limit,
> no minimum spend. Any client holding USDC on Base can call any endpoint immediately.
> Failed requests (4xx/5xx) are never settled, so errors and retries cost nothing.

If you are an agent deciding what to call, read https://x.c00l.site/index.json — it has the same
catalogue as structured JSON with per-field types, worked examples and atomic-unit prices.

## What these services do, in one line each

- **readable** (readable.x.c00l.site) — Any URL to clean, LLM-ready Markdown. 4 paid endpoints, $0.004–$0.003.
- **dataforge** (dataforge.x.c00l.site) — Deterministic data conversion, query, schema and diff. 6 paid endpoints, $0.002–$0.002.
- **netintel** (netintel.x.c00l.site) — DNS, email deliverability, TLS and IP intelligence. 5 paid endpoints, $0.002–$0.005.
- **aisearch** (aisearch.x.c00l.site) — Web search with citations that cannot be invented. 4 paid endpoints, $0.008–$0.25.
- **structura** (structura.x.c00l.site) — Any source plus your JSON Schema, out comes conforming JSON. 5 paid endpoints, $0.015–$0.006.

## How to pay

x402 v2, scheme `exact`, identical on every endpoint:

1. Send the request normally, with no authentication.
2. You get `402` with a `payment-required` header containing base64 JSON:
   `{ x402Version, resource, accepts: [{ scheme, network, amount, asset, payTo, maxTimeoutSeconds, extra }] }`
3. Sign `accepts[0]` as an **EIP-3009 TransferWithAuthorization** over the USDC EIP-712 domain.
   This is an off-chain signature: no gas, no on-chain transaction from you.
4. Replay the **identical** request with the base64 payload in a `payment-signature` header.
5. You get `200` plus a `payment-response` header: base64 `{ success, transaction }`.

| parameter | value |
|---|---|
| network | `eip155:8453` (Base mainnet, chain id 8453) |
| asset | `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` (USD Coin, 6 decimals) |
| payTo | `0x49db736f346BD2f68E9b97069E2E090222d75c82` |
| facilitator | `https://facilitator.payai.network` (covers gas; you need no ETH) |
| maxTimeoutSeconds | 300 |
| eip712 domain | `{"name":"USD Coin","version":"2"}` |

Prices are quoted twice everywhere: a USD string for display (`$0.004`) and USDC atomic units
for arithmetic (`"4000"`). 1 USDC = 1000000 atomic units.

Reference client (JavaScript):

```js
import { wrapFetchWithPaymentFromConfig } from "@x402/fetch";
import { ExactEvmScheme } from "@x402/evm/exact/client";
import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount(process.env.PRIVATE_KEY);
const pay = wrapFetchWithPaymentFromConfig(fetch, {
  schemes: [{ network: "eip155:*", client: new ExactEvmScheme(account) }],
});

const res = await pay("https://readable.x.c00l.site/extract", {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({ url: "https://example.com" }),
});
```

## Free endpoints — no payment, no signup

Every service serves `GET /`, `GET /health` and `GET /openapi.json` for free. Beyond that:

- `GET https://dataforge.x.c00l.site/formats` — Supported formats, transform ops and hard limits
- `POST https://dataforge.x.c00l.site/detect` — Sniff the format of a document
- `GET https://netintel.x.c00l.site/whoami` — Your IP, geo, ASN, TLS version and cipher, HTTP protocol, Cloudflare colo and TCP RTT
- `GET https://structura.x.c00l.site/limits` — Machine-readable limits and prices
- `POST https://structura.x.c00l.site/validate` — Dry-run: check a JSON Schema is usable, free

Start with `GET https://netintel.x.c00l.site/whoami`: it does real work, costs nothing, and
proves the estate is reachable.

## Conventions

- **Auth:** none. No accounts, no API keys, no rate limits, no quotas.
- **Errors:** `{"error":{"code":"snake_case","message":"..."}}`.
- **Failed calls are free.** Any status >= 400 skips settlement entirely. Input is validated
  before the 402 where possible, so malformed input never even produces a challenge.
- **CORS:** `Access-Control-Allow-Origin: *` everywhere, with the x402 headers exposed.
- **Content type:** `application/json` in and out on every paid endpoint.
- **Discovery:** every paid endpoint declares the x402 bazaar extension and is indexed in the
  Coinbase Developer Platform x402 discovery API with its input schema and a worked example.

# Services

## readable — Any URL to clean, LLM-ready Markdown

Base URL: https://readable.x.c00l.site
Tags: markdown, scraping, rag, web

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.

### POST|GET https://readable.x.c00l.site/extract — **$0.004** (4000 atomic USDC)

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.

- Required: `url`
- Optional: `format`, `includeImages`, `includeLinks`, `maxChars`
  - `url` — string — absolute http(s) URL of the page.
  - `format` — enum markdown|text|html (default markdown).
  - `includeImages` — boolean (default true) — keep ![alt](src).
  - `includeLinks` — boolean (default true) — keep [text](url).
  - `maxChars` — integer 100..2000000 — truncate on a word boundary.
- Example body: `{"url":"https://en.wikipedia.org/wiki/Markdown","format":"markdown"}`
- Returns: `{ url, finalUrl, title, byline, publishedAt, siteName, lang, excerpt, content, wordCount, readingTimeMinutes, truncated, meta }`

### POST|GET https://readable.x.c00l.site/unfurl — **$0.001** (1000 atomic USDC)

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.

- Required: `url`
- Optional: none
  - `url` — string — absolute http(s) URL.
- Example body: `{"url":"https://github.com"}`
- Returns: `{ url, title, description, image, favicon, canonical, siteName, type, themeColor, author, date, feeds, oembed }`

### POST|GET https://readable.x.c00l.site/links — **$0.002** (2000 atomic USDC)

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).

- Required: `url`
- Optional: `limit`
  - `url` — string — absolute http(s) URL.
  - `limit` — integer — cap the number of links returned.
- Example body: `{"url":"https://news.ycombinator.com"}`
- Returns: `{ url, count, links: [{ href, text, rel, region, internal, nofollow }] }`

### POST https://readable.x.c00l.site/batch — **$0.003 per URL** (3000 atomic USDC)

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.

- Required: `urls`
- Optional: `format`, `includeImages`, `includeLinks`, `maxChars`
  - `urls` — string[] — 1..20 absolute http(s) URLs.
  - `format` — enum markdown|text|html (default markdown).
  - `includeImages` — boolean (default true).
  - `includeLinks` — boolean (default true).
  - `maxChars` — integer — per-document truncation.
- Example body: `{"urls":["https://example.com","https://example.org"],"format":"markdown"}`
- Returns: `{ count, results: [{ ok, url, ...extract | error }] }`
- Per-item pricing: total = 3000 × len(`urls`), max 20 items. One signature covers the batch.

Free on readable: `GET /`, `GET /health`, `GET /openapi.json`

---

## dataforge — Deterministic data conversion, query, schema and diff

Base URL: https://dataforge.x.c00l.site
Tags: data, csv, yaml, json-schema

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.

### POST https://dataforge.x.c00l.site/convert — **$0.002** (2000 atomic USDC)

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.

- Required: `data`, `to`
- Optional: `from`, `options`, `fromOptions`, `toOptions`
  - `data` — string — the source document.
  - `to` — enum json|jsonl|csv|tsv|yaml|toml|xml|ini|properties.
  - `from` — same enum, or auto (default) to sniff it.
  - `options` — object — shared parser/serialiser options (delimiter, indent, rootName...).
  - `fromOptions` — object — parser options for the source format only.
  - `toOptions` — object — serialiser options for the target format only.
- Example body: `{"data":"name,age\nada,36","from":"csv","to":"json"}`
- Returns: `{ data, from, to, bytes, rows }`

### POST https://dataforge.x.c00l.site/query — **$0.002** (2000 atomic USDC)

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.

- Required: `data`, `path`
- Optional: `from`, `syntax`, `limit`, `pathStyle`, `to`, `options`
  - `data` — string — the source document.
  - `path` — string — e.g. `$.items[?(@.price<10)].name` or `/items/0/name`.
  - `syntax` — enum jsonpath|pointer (default jsonpath).
  - `limit` — integer — cap matches.
  - `to` — output format.
  - `from` — source format enum, or auto (default) to sniff it.
  - `pathStyle` — enum dot|bracket — how returned match paths are rendered.
  - `options` — object — shared parser/serialiser options.
- Example body: `{"data":"{\"items\":[{\"name\":\"a\",\"price\":5}]}","from":"json","path":"$.items[?(@.price<10)].name"}`
- Returns: `{ matches, count, paths }`

### POST https://dataforge.x.c00l.site/schema — **$0.003** (3000 atomic USDC)

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.

- Required: `data`
- Optional: `from`, `validate`, `options`
  - `data` — string — the document.
  - `validate` — object — a JSON Schema to check against. Omit to infer instead.
  - `from` — source format enum, or auto (default) to sniff it.
  - `options` — object — shared parser options.
- Example body: `{"data":"{\"id\":1,\"email\":\"a@b.com\"}","from":"json"}`
- Returns: `{ schema } or { valid, errors: [{ pointer, message, keyword }] }`

### POST https://dataforge.x.c00l.site/transform — **$0.003** (3000 atomic USDC)

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.

- Required: `data`, `pipeline`
- Optional: `from`, `to`, `options`, `toOptions`
  - `data` — string — the source document.
  - `pipeline` — object[] — ordered ops, each { op, ...args }.
  - `to` — output format.
  - `from` — source format enum, or auto (default) to sniff it.
  - `options` — object — shared parser options.
  - `toOptions` — object — serialiser options for the target format.
- Example body: `{"data":"region,sales\neu,10\neu,5\nus,7","from":"csv","pipeline":[{"op":"groupBy","by":["region"],"agg":{"sales":"sum"}}],"to":"json"}`
- Returns: `{ data, rows, applied }`

### POST https://dataforge.x.c00l.site/diff — **$0.002** (2000 atomic USDC)

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.

- Required: `a`, `b`
- Optional: `from`, `fromA`, `fromB`, `options`
  - `a` — string — the left document.
  - `b` — string — the right document.
  - `fromA` — format of `a` (default auto).
  - `fromB` — format of `b` (default auto).
  - `from` — format of both documents, if they share one (default auto).
  - `options` — object — shared parser options.
- Example body: `{"a":"{\"v\":1,\"name\":\"x\"}","b":"{\"v\":2,\"name\":\"x\"}"}`
- Returns: `{ patch: [RFC6902 ops], summary, counts: { add, remove, replace } }`

### POST https://dataforge.x.c00l.site/patch — **$0.002** (2000 atomic USDC)

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.

- Required: `data`, `patch`
- Optional: `from`, `to`, `options`, `toOptions`
  - `data` — string — the document to patch.
  - `patch` — object[] — RFC 6902 operations.
  - `to` — output format.
  - `from` — source format enum, or auto (default) to sniff it.
  - `options` — object — shared parser options.
  - `toOptions` — object — serialiser options for the target format.
- Example body: `{"data":"{\"v\":1}","patch":[{"op":"replace","path":"/v","value":2}]}`
- Returns: `{ data, applied }`

Free on dataforge: `GET /`, `GET /health`, `GET /openapi.json`, `GET /formats`, `POST /detect`

---

## netintel — DNS, email deliverability, TLS and IP intelligence

Base URL: https://netintel.x.c00l.site
Tags: dns, tls, email, asn

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.

### POST https://netintel.x.c00l.site/dns — **$0.002** (2000 atomic USDC)

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.

- Required: `name`
- Optional: `types`, `dnssec`, `crossCheck`
  - `name` — string — the domain to resolve.
  - `types` — string[] — up to 12 of A, AAAA, MX, TXT, NS, CNAME, SOA, PTR, SRV, CAA, DS, DNSKEY, TLSA, SVCB, HTTPS... (default A, AAAA, MX, TXT, NS).
  - `dnssec` — boolean — request and report DNSSEC status.
  - `crossCheck` — boolean — compare against a second resolver.
- Example body: `{"name":"cloudflare.com","types":["A","MX","TXT"]}`
- Returns: `{ name, records: { A: [...], MX: [...] }, dnssec, crossCheck, warnings }`

### POST https://netintel.x.c00l.site/email — **$0.003** (3000 atomic USDC)

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.

- Required: `email`
- Optional: none
  - `email` — string — an address (the domain is audited).
- Example body: `{"email":"hello@stripe.com"}`
- Returns: `{ email, domain, valid, mx, spf, dmarc, dkim, disposable, role, score, warnings }`

### POST https://netintel.x.c00l.site/tls — **$0.004** (4000 atomic USDC)

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.

- Required: `host`
- Optional: `port`, `probeVersions`, `httpHeaders`
  - `host` — string — hostname to connect to.
  - `port` — integer (default 443).
  - `probeVersions` — boolean — probe which TLS versions are accepted.
  - `httpHeaders` — boolean — fetch and grade security headers too.
- Example body: `{"host":"badssl.com","httpHeaders":true}`
- Returns: `{ host, grade, certificate: { subject, issuer, notBefore, notAfter, sans, ... }, chain, versions, headers, findings }`

### POST https://netintel.x.c00l.site/ip — **$0.002** (2000 atomic USDC)

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.

- Required: `ip`
- Optional: `dnsbl`
  - `ip` — string — IPv4, IPv6, CIDR block, or hostname. Max 260 chars.
  - `dnsbl` — boolean (default true) — query DNS blocklists (public IPv4 only).
- Example body: `{"ip":"8.8.8.8"}`
- Returns: `{ ip, version, asn, asOrg, geo, reverse, kind, dnsbl, warnings }`

### POST https://netintel.x.c00l.site/propagation — **$0.005** (5000 atomic USDC)

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.

- Required: `name`
- Optional: `type`, `resolvers`
  - `name` — string — the record name.
  - `type` — enum A|AAAA|MX|TXT|NS|CNAME|SOA|CAA|SRV|... (default A).
  - `resolvers` — string[] — subset of resolvers to query.
- Example body: `{"name":"example.com","type":"A"}`
- Returns: `{ name, type, consensus, agreement, resolvers: [{ name, answer, ms, ok }] }`

Free on netintel: `GET /`, `GET /health`, `GET /openapi.json`, `GET /whoami`

---

## aisearch — Web search with citations that cannot be invented

Base URL: https://aisearch.x.c00l.site
Tags: search, citations, research, ai

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.

### POST https://aisearch.x.c00l.site/answer — **$0.008** (8000 atomic USDC)

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.

- Required: `query`
- Optional: `recency`
  - `query` — string — the question.
  - `recency` — enum day|week|month|year|any — restrict source age.
- Example body: `{"query":"What is the current block time on Base?"}`
- Returns: `{ answer, citations: [{ n, url, title, snippet }], confidence, falsePremise }`

### POST https://aisearch.x.c00l.site/search — **$0.02** (20000 atomic USDC)

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.

- Required: `query`
- Optional: `depth`, `maxResults`, `recency`, `includeRaw`
  - `query` — string — the search query.
  - `depth` — enum quick|standard (default quick). standard runs a counter-evidence pass.
  - `maxResults` — integer — number of sources to consider.
  - `recency` — enum day|week|month|year|any.
  - `includeRaw` — boolean — include the unsynthesised result set.
- Example body: `{"query":"x402 protocol adoption 2026","depth":"standard"}`
- Returns: `{ answer, citations, results, followUps }`

### POST https://aisearch.x.c00l.site/compare — **$0.03** (30000 atomic USDC)

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.

- Required: `subjects`
- Optional: `criteria`, `recency`
  - `subjects` — string[] — 2..6 things to compare.
  - `criteria` — string[] — dimensions to compare on. Inferred if omitted.
  - `recency` — enum day|week|month|year|any.
- Example body: `{"subjects":["Cloudflare Workers","AWS Lambda"],"criteria":["cold start","pricing"]}`
- Returns: `{ verdict, table (markdown), matrix, deciders, caveats, citations }`

### POST https://aisearch.x.c00l.site/research — **$0.25** (250000 atomic USDC)

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.

- Required: `query`
- Optional: `focus`, `recency`, `maxTurns`
  - `query` — string — the research question.
  - `focus` — string — steer what the report should emphasise.
  - `recency` — enum day|week|month|year|any.
  - `maxTurns` — integer — cap the agent loop.
- Example body: `{"query":"State of stablecoin micropayment rails for AI agents","maxTurns":6}`
- Returns: `{ report (markdown), plan, findings, gaps, counterEvidence, citations, turns }`

Free on aisearch: `GET /`, `GET /health`, `GET /openapi.json`

---

## structura — Any source plus your JSON Schema, out comes conforming JSON

Base URL: https://structura.x.c00l.site
Tags: extraction, json-schema, llm, structured

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.

### POST https://structura.x.c00l.site/extract — **$0.015** (15000 atomic USDC)

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.

- Required: `source`, `schema`
- Optional: `instructions`, `strict`, `maxAttempts`, `maxChars`
  - `source` — object — exactly one of { url } | { html } | { text }.
  - `schema` — object — a JSON Schema. Make fields nullable; absent values come back null.
  - `instructions` — string — extra guidance for ambiguous fields.
  - `strict` — boolean — fail rather than widen the schema.
  - `maxAttempts` — integer — repair attempts before giving up (and not charging).
  - `maxChars` — integer — truncate the source.
- Example body: `{"source":{"url":"https://example.com/product"},"schema":{"type":"object","properties":{"name":{"type":["string","null"]},"price":{"type":["number","null"]}}}}`
- Returns: `{ data, confidence: { field: 0..1 }, absent: [...], attempts, validated: true }`

### POST https://structura.x.c00l.site/infer — **$0.02** (20000 atomic USDC)

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.

- Required: `source`
- Optional: `instructions`, `maxAttempts`, `maxChars`
  - `source` — object — exactly one of { url } | { html } | { text }.
  - `instructions` — string — steer the schema design.
  - `maxAttempts` — integer.
  - `maxChars` — integer.
- Example body: `{"source":{"url":"https://example.com/invoice"}}`
- Returns: `{ schema, data, documentType, confidence, absent }`

### POST https://structura.x.c00l.site/table — **$0.012** (12000 atomic USDC)

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.

- Required: `source`
- Optional: `instructions`, `maxChars`
  - `source` — object — exactly one of { url } | { html } | { text }.
  - `instructions` — string — e.g. which table you care about.
  - `maxChars` — integer.
- Example body: `{"source":{"url":"https://en.wikipedia.org/wiki/List_of_countries_by_GDP_(nominal)"}}`
- Returns: `{ tables: [{ caption, headers, rows, columns: [{ name, type, unit }], csv }] }`

### POST https://structura.x.c00l.site/batch — **$0.012 per source** (12000 atomic USDC)

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.

- Required: `sources`, `schema`
- Optional: `instructions`, `strict`, `maxAttempts`, `maxChars`
  - `sources` — object[] — 1..15, each exactly one of { url } | { html } | { text }.
  - `schema` — object — one JSON Schema applied to all of them.
  - `instructions` — string — extra guidance, applied to every item.
  - `strict` — boolean — fail rather than widen the schema.
  - `maxAttempts` — integer — repair attempts per item before that item fails.
  - `maxChars` — integer — per-source truncation.
- Example body: `{"sources":[{"url":"https://example.com/a"},{"url":"https://example.com/b"}],"schema":{"type":"object","properties":{"title":{"type":["string","null"]}}}}`
- Returns: `{ count, results: [{ ok, data, confidence, absent } | { ok: false, error }] }`
- Per-item pricing: total = 12000 × len(`sources`), max 15 items. One signature covers the batch.

### POST https://structura.x.c00l.site/classify — **$0.006** (6000 atomic USDC)

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.

- Required: `text`, `labels`
- Optional: `multi`, `rubric`, `threshold`
  - `text` — string — the text to classify.
  - `labels` — string[] — the allowed label set.
  - `multi` — boolean — allow more than one label.
  - `rubric` — string — how to decide between labels.
  - `threshold` — number 0..1 — minimum score to include.
- Example body: `{"text":"The invoice is 30 days overdue.","labels":["billing","support","sales"]}`
- Returns: `{ label, scores: { label: 0..1 }, margin, multi }`

Free on structura: `GET /`, `GET /health`, `GET /openapi.json`, `GET /limits`, `POST /validate`


## Portal endpoints

- `GET https://x.c00l.site/` — This landing page
- `GET https://x.c00l.site/index.json` — Machine-readable catalogue for agents
- `GET https://x.c00l.site/llms.txt` — LLM-readable summary of the catalogue
- `GET https://x.c00l.site/openapi.json` — Merged OpenAPI 3.1 across all five services
- `GET https://x.c00l.site/status` — Live health of all five backends
- `GET https://x.c00l.site/health` — Liveness probe
- `GET https://x.c00l.site/robots.txt` — Crawler policy (AI crawlers explicitly welcome)
- `GET https://x.c00l.site/sitemap.xml` — Sitemap