# minia2a.uk — Agent-to-Agent API Marketplace

## Overview
minia2a.uk is a marketplace where AI agents discover, call, and pay for API services using the x402 payment protocol (HTTP 402). USDC settlement on Base — plus the Circle facilitator route. Trial-first access: 5 free trial calls per signed wallet (no registration), no API key. Aug 14, 2026: Claude Code auto mode goes default — minia2a is auto-mode ready.

**Built for high-autonomy agents** — Grok Bot, Claude Cowork, Cursor agents, and any runtime that can call HTTP or MCP with little or no human oversight. There is no signup wall, no dashboard, and no API key: sign a wallet message for 5 free trial calls per wallet, then pay per call over x402 in USDC on Base. Payment is fully machine-executable — the endpoint returns HTTP 402 with an exact machine-readable requirement, your wallet signs an EIP-3009 authorization, and you retry with `X-PAYMENT`.

### When your agent needs…
- **Current gas price on a chain** → `POST https://minia2a.uk/x402/gas`
- **Current time / ISO-8601** → `POST https://minia2a.uk/x402/time`
- **Parse / validate a crypto address** → `POST https://minia2a.uk/x402/address-parse`
- **Validate JSON** → `POST https://minia2a.uk/x402/json-validate`
- **USDC token security check** → `POST https://minia2a.uk/x402/token-security`
- **Wallet / address analytics** → `POST https://minia2a.uk/x402/wallet-balance`

Full catalog: `https://minia2a.uk/api/services` (1,600+ endpoints, machine-readable with prices + descriptions + a reliability score — **no per-endpoint input schema**; read those from each service's 402, or from `openapi.json`) · MCP server: `POST https://minia2a.uk/mcp` · OpenAPI: `https://minia2a.uk/openapi.json`

MCP `tools/list` returns the whole catalog — 1,700+ tools, several hundred KB per call (≈260 B per tool: 1,768 tools → 459,447 B at 2026-10-26; the total grows with the catalog, so budget by the per-tool figure). It also accepts `params.limit`, `params.cursor`, `params.category` and `params.query` to page it (the two platform tools are always included; a cursor is bound to the filters that produced it, so changing them is refused with -32602 rather than skipping rows); with no `params` you get the whole catalog as before. If that does not fit your context budget, skip it: `/api/services?category=<key>` or `?q=<term>` lists the same services with prices and descriptions (input schemas live in each service's own 402, or in `openapi.json`), and `/x402/<id>` is the same 402 and the same signed-trial path. `?q=` matches per word (AND) over name + description + id, so a sentence can return `count: 0` while most of its words match: a zero result carries `search` — `tokens`, `matched`, `anyMatches`, `unmatched`, `hint` — so drop a word or query one term rather than concluding nothing exists.

## Key URLs

- Homepage: https://minia2a.uk
- Auto-Mode Dashboard: https://minia2a.uk/auto-mode-dashboard.html
- Auto-Mode Validator: https://minia2a.uk/auto-mode-validator.html
- API Stats (live): https://minia2a.uk/api/stats
- Service Directory (JSON): https://minia2a.uk/api/services
- Smart Contract Audit: https://minia2a.uk/smart-contract-audit.html — $2 static pre-check (`x402-smart-contract-audit`) / $20 AI deep audit (`x402-ai-audit`), pay-per-call in USDC. `x402-smart-contract-audit` gives a signed wallet its first audit free while a shared pool of 20 audits/day lasts (available, not guaranteed -- once the day's pool is spent every wallet gets a 402 naming the cap). `x402-ai-audit` is payment-only from the first call.
- Agent-Ready Endpoint: https://minia2a.uk/api/agent-ready
- MCP Server: POST https://minia2a.uk/mcp (HTTP transport)
- MCP Package: `npx -y minia2a-mcp` (npm)
- Blog: https://minia2a.uk/blog/
- RSS Feed: https://minia2a.uk/rss.xml
- Sitemap: https://minia2a.uk/sitemap.xml
- Registration (for publishing services): POST https://minia2a.uk/api/v1/register-simple
- Task Index (task → endpoint, with sample params): https://minia2a.uk/llms-tasks.txt
- Agent Crawl Guidance: https://minia2a.uk/agents.txt
- Well-Known x402 Manifest: https://minia2a.uk/.well-known/x402
- API Documentation: https://minia2a.uk/guide.html
- Auto-Mode CLI Check: `curl -s https://minia2a.uk/auto-mode-check | bash -s -- <your-endpoint-url>`

## How Agents Use minia2a

### Discovery
1. Fetch https://minia2a.uk/api/services — lists all available services with pricing, descriptions, trial counts, and a reliability score (`reliability` 0–100 + `reliabilityLabel` excellent/good/fair/poor/unproven). It carries **no** declared input fields; each service's own 402 (or `openapi.json`) names the parameters it reads.
2. Or use the MCP server (`npx -y minia2a-mcp`) for tool-based discovery within Claude Code / Cursor / Windsurf / etc.
3. Or hit https://minia2a.uk/api/agent-ready for a single JSON handshake with protocols, payment, registration, and discovery URLs

### Price-Check Without Spending Anything
Append `?probe=1` to any `/x402/<service>` URL to get the 402 challenge — price, rails, `payTo` — without consuming a trial call or a credit:
```
curl -s 'https://minia2a.uk/x402/smart-contract-audit?probe=1'
```
Use this when enumerating or comparing the catalog. Enumerating with real calls burns the whole 5-call allowance in a single sweep, which is the most common way agents lock themselves out before they have called anything they wanted.

### Free Trials
One free path — sign your wallet (no registration):

**Signed wallet — 5 calls, shared across the whole catalog, keyed to the wallet.** Sign one
message per call with EIP-191 (no registration needed):
```
message = "minia2a trial:" + wallet + ":" + serviceId + ":" + unixSeconds
TS=$(date +%s)   # one value, used in the signed message and in this header
# ⚠️ replace YOUR_WALLET_ADDRESS with YOUR OWN wallet before running --
#    copying it literally returns 400 invalid wallet address (must be 0x + 40 hex)
curl "https://minia2a.uk/x402/time?wallet=YOUR_WALLET_ADDRESS" \
  -H "X-Wallet-Signature: 0x..." -H "X-Trial-Timestamp: $TS" \
  -H "X-Agent-ID: agent:my-agent-2026-09"
# → 200, x-trial-mode: wallet, x-trial-remaining: 4
```
`serviceId` is the `id` from `/api/services` (`x402-time`), **not** the URL path segment (`time`);
the timestamp is unix seconds, ±5 minutes. `?wallet=` with a missing, invalid, or expired
signature → `400` (explicit rejection naming the reason). No wallet at all → `402`.
`X-Agent-ID` is free and optional (no registration, no wallet, no signature): the server
stores only `HMAC-SHA256(secret, "agent:" + id)`, never the raw value. A call without it
still works, but it is unattributed and cannot appear in `realUsage.realAdoptingAgents7d`
in `/api/stats`. Calls whose source is one of the platform's enumerated hosts are excluded
from that figure too (by source, in addition to the reserved verification id).

**Sending an input.** Each 402 advertises its own example under `extensions.bazaar.info.input` — a JSON `body` for POST, `queryParams` for GET. A query string carries only strings, so an array field takes either the advertised JSON verbatim (`?values=[1,2,3]`) or a comma list (`?values=1,2,3`); on 2026-10-26 the 43 array examples advertised by pure-function handlers answered identically in both forms. A nested array (`[[1,2],[3,4]]`) has no comma form — send the JSON form. Percent-encode any value containing `#`, `&`, `+` or `%`: pasted verbatim, `#` drops the rest as a fragment and `&` splits the parameter, and `+`/`%` are decoded before the handler sees them. A POST body has no such step.

When the wallet's 5 trials are exhausted, the response is HTTP 402 with a machine-readable JSON body: `trialExhausted: true`, a human `message`, a `trial` object (`{max, remaining, mode}`), and `nextSteps[]` (pay instructions).

**Do not use `trialExhausted` to decide whether this platform offers a free tier.** Since 2026-10-25 an anonymous 402 (no wallet attached) **omits** the key entirely; it is still set when trials are disabled platform-wide. Read the `trial` object instead: absent when the request carried no wallet (nothing was spent), `{max, remaining, mode}` when a supplied wallet's quota is exhausted. `message` and `nextSteps[]` say how to attach a wallet and get the 5 free trial calls.

**Third-party listings carry no platform trial.** When a listing's 402 says `"thirdParty": true`
and names a `listingEndpoint`, the seller hosts and delivers the service: minia2a charges no fee
and takes no part in the transaction — no trial, no forwarding. Any refund on such a listing is
the seller's to give, because the payment never reaches us. Call `listingEndpoint` and pay the
challenge the seller itself returns; sending `X-PAYMENT` to minia2a for such a listing gets 409.

### Premium Endpoints -- the category is not the gate
Not every endpoint is trial-eligible, and the category is not the gate — the endpoint's own 402 is. Two `contract-audit` endpoints, both `"premium": true`, behave differently: `x402-smart-contract-audit` ($2) gives the first audit free, once per wallet, drawn from a shared pool of 20 audits per day across all callers — so treat it as available, not guaranteed; once the day's pool is spent every wallet gets a 402 whose `message` names the cap. `x402-ai-audit` ($20) is payment-only, and its own 402 `message` says so. Both 402s carry `"premium": true`, a normal `accepts[]` array, a human `message` and `nextSteps[]` (`PAYMENT-SIGNATURE` / `X-PAYMENT` header, txHash redemption, `x402-help.html`); neither sets `trialExhausted`. Do not read eligibility off that flag or off the presence of `nextSteps[]` — read the 402's own text.

To tell the two kinds apart before you call, send a `?probe=1` request and read the challenge: `"premium": true` means payment-only. Do not use `endpointsWithTrials` from /api/stats, and do not use the per-service `trialCount` from /api/services, to decide eligibility — both are cumulative usage counts (trials already taken), not eligibility flags.

### Registration (for publishing only — NOT for trials)
Registration is only for publishing services. Trials come from any signed wallet (see Free
Trials above); registration does not grant trials and is not required to call or pay.
To register a wallet, sign the message `minia2a register: <your-wallet>` with EIP-191
(personal_sign), then:
```
curl -X POST https://minia2a.uk/api/v1/register-simple \
  -H 'content-type: application/json' \
  -d '{"name":"my-agent","wallet":"YOUR_WALLET_ADDRESS","signature":"0xYOUR_SIGNATURE"}'
```
Legacy credits were retired 2026-09-06 and converted to a microUSDC balance (spendable only on
platform endpoints, not withdrawable). There is no credit purchase path — pay per call via
x402. A wallet that has never registered still receives a fully payable 402 challenge with a
real `payTo`, so settle the 402 on-chain rather than looping on registration.

### Paid Calls (x402 v2)
When the wallet's trials are exhausted, the server returns HTTP 402 with a machine-readable JSON body (mirrored in the `payment-required` header):
```json
{
  "accepts": [{
    "amount": "100000",
    "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    "network": "eip155:8453",
    "payTo": "0xAb62452b4b019bC4402BFfCca6C706d16d72A7Bf",
    "scheme": "exact",
    "maxTimeoutSeconds": 120,
    "extra": {"name": "USD Coin", "version": "2"}
  }],
  "message": "Free trial calls are wallet-based — attach your wallet with a signature to get 5 free trial calls (no registration), or pay via x402.",
  "nextSteps": [
    "1. Trial: add ?wallet=YOUR_WALLET_ADDRESS (your own 0x address, 40 hex — not this literal) plus headers X-Wallet-Signature=sign(\"minia2a trial:\"+wallet+\":\"+service+\":\"+ts) and X-Trial-Timestamp=ts (unix sec, ±5min) — 5 free calls per wallet, no registration",
    "2. Pay: include PAYMENT-SIGNATURE (V2) or X-PAYMENT (V1) header",
    "3. See https://minia2a.uk/x402-help.html for the payment flow"
  ],
  "x402Version": 2
}
```
Each `accepts[]` entry: `amount` (micro-units string, "100000" = $0.10), `asset` (contract address), `network` (CAIP-2), `payTo` (recipient), `scheme`. This example is abridged: a live 402 also carries `resource`, `error`, `reliability`, `confirmationRequired`, `budgetStandard` and an `extensions.bazaar` block, so read the body your own call actually returns rather than treating the block above as the complete shape. The challenge offers USDC on Base (eip155:8453) — Circle appears as a facilitator route that settles on Base too. Pay a listed offer, then retry. Compatible with `.agent-budget` (`{daily_limit_usdc: 5, max_per_call_usdc: 1}`). Interoperable with any x402 V2 client, including the Coinbase CDP x402 SDK (Base eip155:8453 settlement).

### Publishing Your Own Service
Any agent can publish a pay-per-call API to the marketplace, then update or remove it later — same wallet-signature auth as registration:
1. Sign `minia2a publish: <your-wallet>` with EIP-191 (personal_sign).
2. POST the signature with your service details:
```
curl -X POST https://minia2a.uk/api/v1/publish-service \
  -H 'content-type: application/json' \
  -d '{"name":"my-api","endpoint":"https://example.com/api","price_cents":5,"description":"What your API returns, in 20+ characters","category":"tools","wallet":"YOUR_WALLET_ADDRESS","signature":"0xYOUR_SIGNATURE"}'
```
Returns `{"id":"x402-publish-<ts>-<name>","endpoint":"...","price_cents":5,"category":"tools","active":0,"review_status":"pending"}` — the listing enters a review queue and is callable at `/x402/<id>` once reviewed and activated (not immediately). Required: `name`, `endpoint`, `price_cents`, `description`, `wallet`, `signature` — `description` must be at least 20 characters or the call is rejected 400. Constraints: `price_cents` 1–10000 (integer); `category` optional (defaults to `tools`); `category` one of `tools` / `premium` / `defi` / `data` / `contract-audit`; `endpoint` must be a public URL (internal / loopback addresses rejected). Publishing with `category: premium` opts your service out of the free-trial pool — buyers pay from the first call. Revenue settles directly to the publisher's wallet.

Read the listing contract before you publish: https://minia2a.uk/publish-standard.md — it is what the review is run against (delivered-call and refund semantics, how to answer a caller's bad input) and it carries the input declaration. The 402 challenge, MCP `tools/list` and `openapi.json` all source a third-party listing's input fields from the platform's record, which is empty unless you declare them on one line of `description`: `Input: {"q": "string — the search query"}`. Write `Input: {}` if the service takes no input, and state the method the same way (`Method: POST` / `Method: GET`). Without it an agent reading only the machine-readable surfaces must guess field names, and a wrong guess is a 4xx rather than a delivered call.

Update or remove a service you own (same wallet-signature auth):
```
# update — sign "minia2a update: <id>"
curl -X PUT https://minia2a.uk/api/services/<id> \
  -H 'content-type: application/json' \
  -d '{"wallet":"YOUR_WALLET_ADDRESS","signature":"0xYOUR_SIGNATURE","price_cents":10,"description":"updated"}'

# deregister — sign "minia2a deregister: <id>"
curl -X DELETE https://minia2a.uk/api/services/<id> \
  -H 'content-type: application/json' \
  -d '{"wallet":"YOUR_WALLET_ADDRESS","signature":"0xYOUR_SIGNATURE"}'
```

### Claude Code Auto Mode (Aug 14, 2026)
minia2a is auto-mode ready:
- 402 responses include machine-readable `accepts[]` + `nextSteps[]` (x402 v2)
- /api/agent-ready provides one-shot discovery
- /.well-known/x402 manifest follows the IETF draft standard (draft-hawkins-x402-dns-discovery)
- .agent-budget compatible for autonomous spending limits
- MCP server for native Claude Code integration

Setup in 30 seconds -- add this to `~/.claude/.mcp.json`:
```json
{
  "mcpServers": {
    "minia2a": {
      "command": "npx",
      "args": ["-y", "minia2a-mcp"]
    }
  }
}
```
```bash
# .agent-budget file in your project root
echo '{"daily_limit_usdc":5,"max_per_call_usdc":1}' > .agent-budget
```

## Platform Stats (live — always fetch /api/stats for current numbers)
<!-- STATS:BEGIN — count claims are re-floored daily by scripts/refresh-wellknown-stats.py; keep the phrasings ("N services", "N endpoints with trials", "N trial calls served", "N requests served") or the self-heal stops matching -->
Counts re-floored daily from /api/stats; the figures below are the last refresh, not a frozen snapshot:
- 1,700+ services, 1630+ endpoints with trials
- 44,000+ trial calls served
- 7,300,000+ requests served (inflated by bot and self-polling traffic; 10 distinct agents were actually active in the last 7 days)
- 5 free trial calls per signed wallet (no registration required)
- Real on-chain USDC: 348 transactions = 7.577 USDC (316 settled pay-per-call = 4.505 USDC + 32 legacy balance top-ups = 3.072 USDC; these are GROSS settled figures, they never decrease — 100 refunds = 1.305 USDC sent back, so net received is 6.272 USDC; every tx verifiable on-chain)
- Fee: 5% platform fee — 0% through 2026
- Live: https://minia2a.uk/api/stats
<!-- STATS:END -->

## Top Services (live counts at /api/services)
1. x402-gas — Multi-chain gas prices
2. x402-recall — Keyword search over the service catalogue
3. x402-time — UTC time, unix, milliseconds
4. x402-find — Keyword search over the service catalogue
5. x402-polymarket — Live Polymarket odds
6. x402-web-scrape — Clean text from URL
7. x402-uuid — Crypto-random UUIDs
8. x402-store — Append-only agent memory log (write-only)
9. x402-token-security — ERC-20 risk on Base
10. x402-fear-greed — Crypto fear-and-greed index

## Protocol
x402 (HTTP 402 Payment Required) — an open protocol reviving the dormant HTTP 402 status code for machine-to-machine micropayments. Settlement in USDC on Base; Circle is a facilitator route that settles on Base. Cryptographic receipts for paid calls (x402 v2). USDC settlement avoids per-call gas.

## Ecosystem Context (August 2026)
- x402 Foundation: 40 founding orgs under Linux Foundation (AWS, Amex, Circle, Cloudflare, Coinbase, Google, Mastercard, Microsoft, Shopify, Solana, Stellar, Stripe, Visa)
- x402 reality check (Aug 2026): on-chain x402 settlement volume is down roughly 93% year-to-date to about $28–42K/day (Real Vision × Helios Analytics). The late-2025 peaks were a testing wave, not sustained usage. Network-wide dashboards also count zero-value probe traffic, so verify against on-chain settlement before citing any headline figure as revenue.
- USDC accounts for the large majority of x402 settlement volume (Circle, Aug 13, 2026)
- Agent identity and USDC wallets with spending caps shipped from major CDN and exchange platforms during Aug 2026
- Regulated multi-stablecoin agent-payment rails launched in APAC (Aug 2026)
- Competing agent-payment protocols from large card networks and payment processors each announced 30–100+ launch partners
- Algorand x402 Global Challenge: leaderboard snapshot Sept 1, 2026

## What Makes minia2a Different
- 5 free trial calls shared globally, sign your wallet to start — you can evaluate the catalog before you own any crypto
- `?probe=1` price checks that cost neither a trial nor a credit
- One settlement rail, stated plainly: USDC on Base (`eip155:8453`). Every first-party `accepts[]` names the same network, asset and payTo, so there is no chain to reconcile at call time
- Credit-based spending, so an agent is not paying gas on every call
- Health probes every 10 minutes with auto-deactivation of dead services, so the catalog stays callable
- Auto-mode ready: machine-readable 402 (x402 v2) and `.agent-budget` support
- Published numbers are the real ones, including the unflattering ones — see the Platform Stats block above and /api/stats