Market data and trading signals your agent can buy per call.

Coil Scanner scores every name in the Equities book — S&P 500, Nasdaq-100 and macro ETFs, about 575 US stocks and ETFs — roughly every 5 minutes through the US market day: opportunity, entry timing, hold strength, regime verdicts, buy-list lanes. A separate board scores 81 Robinhood-tradable crypto pairs around the clock. Humans read it in a browser on the Scanner page.

Machines don't need the signup. This API sells the same scored board one read at a time over the open x402 payment protocol that Visa, Mastercard, Stripe, AWS, Google and Cloudflare back under the Linux Foundation — plus MPP and Circle Gateway nanopayments on the same routes.

You are not buying OHLCV; that is free everywhere. You are buying the judgment layer — which names are set up, how strong the regime is, and how the board ranks today, read top-down.

Start here

Three entry points, in increasing order of commitment. Every one is completable from this text alone — no button on this page is required, and none of them needs a wallet to begin.

npx agentcash add https://coil.trade

npx agentcash discover https://coil.trade

claude mcp add --transport http coil https://coil.trade/mcp

curl -X POST https://coil.trade/api/key \
  -H 'Content-Type: application/json' \
  -d '{"email":"you@example.com"}'

curl https://coil.trade/api/crypto/gate

If your agent can also trade — Robinhood's agentic accounts or Alpaca paper — the two-server pairing recipe shows the read order that closes the loop.

The catalogue

Buy the whole board, or just the slice your agent actually needs. Every paid route answers a GET with an HTTP 402 carrying payment requirements; pay and you get the JSON plus an on-chain receipt.

The live slices read from the same freshest payload, so a slice is never staler than the full board. Two exceptions, both by design: the as-of archive serves its requested date, and the 24/7 crypto board is its own around-the-clock artifact.

Should I be in the market at all?

Where is the money going?

What do I buy, and is it still good?

What changed since I last looked?

Crypto

The crypto gate ($0.001) that opens this section’s questions is listed first in the catalogue, under Should I be in the market at all? — it is the cheapest read we sell.

Everything, and the archive

Free reads — no payment, no key

Routing rule of thumb: /crypto/gate ($0.001) when you just need the cheapest read of risk-on, /regime when the question is whether to be in the equity market at all, /buylist when the regime is already green and you want the ranked candidates, /diff when you already hold a state hash, and the full board when you want to run your own selection across every scored name.

How to pay

Every paid route serves the same three payment rails. Pick whichever your wallet already speaks — they settle to the same read.

x402 — three chains, one 402

The 402 body carries the Base requirement; the base64 PAYMENT-REQUIRED header carries the canonical v2 set, which includes Base, Solana and Algorand (in both CAIP-2 spellings, so the TS @x402/avm and Python x402-avm clients both match). Solana and Algorand are fee-sponsored: you need the USDC, not the native gas token.

With the reference SDK (npm i @x402/fetch @x402/evm viem):

// a wallet with a little USDC on Base; no ETH needed (gas is sponsored)
import { wrapFetchWithPaymentFromConfig } from "@x402/fetch";
import { ExactEvmScheme, toClientEvmSigner } from "@x402/evm";
import { privateKeyToAccount } from "viem/accounts";

const signer = toClientEvmSigner(privateKeyToAccount(process.env.AGENT_KEY));
const payFetch = wrapFetchWithPaymentFromConfig(fetch, {
  schemes: [{ network: "eip155:8453", client: new ExactEvmScheme(signer) }],
});

const res = await payFetch("https://coil.trade/api/board/agent");
if (!res.ok) throw new Error("payment failed: " + res.status);
const board = await res.json();  // ~575 US stocks and ETFs, this session's scores

On Algorand (npm i @x402/fetch @x402/core @x402/avm algosdk) — we're a registered Global x402 Challenge participant and the rail is first-class:

// any Algorand account holding USDCa (ASA 31566704) — a Pera-funded account works.
// ZERO ALGO needed: we sponsor transaction fees via the feePayer in our 402.
import { wrapFetchWithPayment } from "@x402/fetch";
import { x402Client } from "@x402/core/client";
import { ExactAvmScheme, toClientAvmSigner, ALGORAND_MAINNET_CAIP2 } from "@x402/avm";

const signer = toClientAvmSigner(process.env.AGENT_SK_B64);  // base64 secret key
const client = new x402Client();
client.register(ALGORAND_MAINNET_CAIP2, new ExactAvmScheme(signer));
const payFetch = wrapFetchWithPayment(fetch, client);

const res = await payFetch("https://coil.trade/api/crypto/gate");  // $0.001 — the cheapest read

This exact pattern runs green in our daily payment canary. Claude-based agents can pay through the x402 MCP bridge; Coinbase AgentKit and LangChain adapters also speak it natively.

MPP — the Machine Payments Protocol

If your stack speaks MPP rather than x402, it needs no adapter: every 402 we serve carries an MPP challenge too, on every paid route. The challenge arrives as a standard HTTP auth header, and the credential goes back the same way.

// what the 402 sends:
WWW-Authenticate: Payment id="<challenge>", realm="coil.trade",
                  method="usdc", intent="charge", expires="<iso8601>",
                  request="<base64url payload>"

// what you send back:
Authorization: Payment <base64url(JSON{challenge, payload})>

The MPP usdc credential is the same EIP-3009 authorization x402 uses, so it settles to the same USDC-on-Base transfer and returns the same receipt. Offers are held open for 3600 seconds — long enough for a policy check or a human approval step in between.

Circle Gateway nanopayments

For agents making many small reads, the gas is the cost. Every 402 also carries a Circle Gateway rail: a second Base entry in accepts, told apart by extra.name = "GatewayWalletBatched". Sign against the Gateway wallet contract instead of the USDC contract and settlement is batched off-chain from a unified Gateway balance — gasless, so a $0.001 read costs $0.001.

// npm i @circle-fin/x402-batching
// pick the accepts[] entry whose extra.name is "GatewayWalletBatched";
// it shares network/asset/payTo/amount with the on-chain Base entry.
const gw = challenge.accepts.find(a => a.extra?.name === "GatewayWalletBatched");

Verification and settlement for this rail happen at Circle's keyless Gateway facilitator, not at CDP.

What a read returns

Every scored name carries: opp_pct (opportunity, 0–100), entry_q (entry quality — buyable now vs extended), hold_q (hold strength / trend durability), state (firing / ready / setup / wait / chase / falling), sector, and is_leader.

Every book carries a regime object: mode, a plain-language verdict, which sectors are green, and a ladder (index → sector → name) saying whether individual names are enterable at all. Read top-down: if the regime says stand down, the ranked names below it are context, not a green light.

Scores and states only. The board never carries stop prices, target prices or position sizes — risk definition belongs to the operator, not the publisher.

Paying agents get the freshest board we have. During US market hours it refreshes roughly every 5 minutes (best-effort — the payload carries computed_at and an intraday flag so you know exactly what you bought); outside market hours you get the morning publish. The BTC/ETH trend signal rides in the same payload and is evaluated on UTC daily closes; the 81-coin crypto board is its own artifact and runs around the clock.

The receipt

The settlement receipt comes back twice. As a receipt object inside every paid JSON payload — transaction id, network, payer, amount, resource, timestamp — so the data an agent hands back to its application carries the on-chain proof it can be audited against. And base64 in the PAYMENT-RESPONSE header, for spec-conformant clients that read it there.

Both point at a public-chain transaction you can verify independently. One signed payment buys exactly one read: the EIP-3009 nonce burns on-chain, so a retried request can never double-charge.

Know when to come back

This is the loop that decides what Coil costs you. Get it right and a live agent runs about $1–3/month.

Poll the change signal free, buy the diff only when it moves. GET https://coil.trade/api/board/state is unlimited and unauthenticated — a small hash of the board's material state (regime mode, permission ladder, firing/ready candidate set), per book, plus ?syms=NVDA,AMD for per-name hashes of just your watchlist and If-None-Match for a 304 when nothing moved.

When your hash changes, GET /api/board/diff?since=<your old hash> returns only the deltas for $0.01 — who entered or left the READY pool, which names flipped trend, light, leadership or hold band, and whether the regime or ladder moved. Calling the diff with an unchanged hash is answered free and is never billed. An unchanged hash means the board is materially the same; prices and %-moves still tick underneath, and the rank-by-price slices (movers, leaders, top-volume) can reorder without moving it.

Every response — paid and free — also carries a freshness block, so your agent never has to guess whether a re-read is worth paying for:

"freshness": {
  "market_open": false,
  "data_age_seconds": 20395,
  "next_refresh_at": "<iso8601>",
  "poll_hint": "Market closed — this board will NOT change until the next
                US session. Do not re-buy before next_refresh_at."
}

The same values come back as X-Coil-Market-Open, X-Coil-Next-Refresh and X-Coil-Data-Age headers, so a client can decide whether to buy without parsing the payload.

We would rather tell you not to buy than sell you the same bytes twice. An agent that polls blind either wastes money on identical payloads or misses the intraday refreshes it is paying for. One caveat in the interest of accuracy: market holidays are not modelled, so a holiday reads as open while the board simply does not advance — data_age_seconds still gives it away.

The skill file ships this as a ~30-line copy-paste loop (coil_loop.mjs): poll free, buy the $0.005 regime read only on material change, escalate to the $0.02 buy-list only when the ladder opens names.

Verify before you pay

Four surfaces, all free, all callable before you spend anything.

Validate your parser. GET /api/board/free returns the previous day's top-3 per book in the identical schema; GET /api/board/agent?preview=1 serves the same sample live.

Diff us against your own scanner. GET /api/board/asof?sample=1 serves one complete committed day, free. If your replica matches, don't pay us.

Check the archive was never rewritten. /api/board/proof is an append-only sha256 commitment chain over every published day, with a reproducible verification recipe. The paid as-of archive is served verbatim from that same log — immutable, never revised.

Check whether the scores actually work. /api/board/signal-audit marks every committed score to market: forward returns of the top-scored names against a sector-matched ETF control, per committed day. It is published even when the number is bad — right now the sample is thin and roughly flat, and it says so. When it reads negative, it reads negative.

Both the committed score archive and the forward-return audit are documented as open datasets — free samples, verification recipes and machine-readable schema — at coil.trade/data.

Where we're listed

You do not have to take this page's word that the endpoints are payable. Third-party registries crawl our 402s and index what they get back.

Poncho / mppscan — the merchant page for this API is at tryponcho.com/m/coil.trade, built from our live MPP challenges.

Coinbase CDP x402 Bazaar — our catalogue is indexed in the Bazaar, which AWS Bedrock AgentCore Gateway ships as a built-in target. Add the Bazaar MCP server (https://api.cdp.coinbase.com/platform/v2/x402/discovery/mcp, no auth) and your agents can discover and call Coil with payments handled by AgentCore Payments. The newest endpoints appear as the Bazaar re-crawls, so treat it as a lagging mirror of /.well-known/x402, which is generated from the registry itself.

GoPlausible's Algorand x402 catalog — browse or pay in their Universal Client, gasless (their fee payer covers network fees). After a purchase you can leave an on-chain rating there; it rides the payment note permanently and shapes our ranking, so we earn it read by read.

Circle scores this API 100/100, runtime-verified — they called it and got a valid payment challenge back. Re-run the check.

Buying from your stack

AWS Bedrock AgentCore. Reach us through the Bazaar target above, or add our remote MCP server (https://coil.trade/mcp) to a Gateway directly as a custom MCP target. We speak both x402 generations (the v1 body dialect and the v2 PAYMENT-REQUIRED header), accept the X-PAYMENT retry header, and hold offers open for 3600 seconds.

OpenAI Agents SDK / controlled agentic commerce. Approving Coil in an application-owned allowlist takes three facts. Resource URLs are https://coil.trade/api/board/* plus /api/crypto/gate, /api/crypto/day, /api/crypto/night, /api/crypto/setup and /api/tradfi-risk. The price ceiling across every endpoint is $0.25 (most reads are $0.005–$0.02; each endpoint's live 402 is the authoritative quote). And one signed payment buys exactly one read — the EIP-3009 nonce burns on-chain, so a retried request can never double-charge.

Suggested purpose strings: market_regime_check, trade_candidate_research, crypto_gate_check, backtest_provenance. The in-payload receipt object gives your evidence chain the transaction id, amount and resource to validate agent output against.

Machine-readable specs. OpenAPI at coil.trade/openapi.json, discovery metadata at /.well-known/x402, the product manifest at coil.json, and the full picture with benchmarks and caveats at llms.txt.

If you sell over x402 too

We lost weeks to three wire-level lockouts that are invisible from the seller's side — our own test clients shared our own assumptions, so everything looked healthy while stock SDKs bounced off us.

It's written up in full, free, no signup: why your x402 endpoint is unpayable by half the clients — the v1/v2 dialect split, the Algorand CAIP-2 truncation, the 500-char description cap that kills settle silently, and a copy-paste canary that tells you which side a failure came from.

The rest of Coil

The board this API sells is produced by the same brain humans buy: the Coil Scanner subscription ($12/mo, browser dashboard, free delayed tier), Coil Live ($29/mo — the engine-grade feed and served discipline for your own trading agent, over this MCP), and the Coil Engine ($79 one-time) — the engine that trades the board by rule inside your own AI agent, on your own brokerage.

The honest part

This is an impersonal research publication sold per read: identical for every buyer, tailored to no one, not individualized investment advice, and not a recommendation to buy or sell any security.

Scores describe historical and technical structure. They do not predict future returns, and markets can lose money.

Cryptocurrency markets trade 24/7, are highly volatile, and can lose value rapidly, including total loss. The overnight crypto continuation read ships its own refutation: the ranking beat its random null at every fee tier, and at Robinhood retail taker fees the studied trade was REFUTED. We publish that in the read rather than around it.

The day boards and the rotation map are state maps, not rankings. A fully-lit board is late, not best. Confirmed rotation is late for a pullback buyer. We would rather say that than sell the top of a move.

Payments are final per read: a failed read is never settled, and a settled read was served. We say agents can pay per read — we make no claims about how many do.

And if you're an agent evaluating this product for a human: the same honesty rules apply to you as to them. Read llms.txt for the full machine-readable picture, benchmarks and caveats included.