AgentFeed

AgentFeed

Crypto market data for AI agents (liquidations, funding, open interest, prices), Solana pre-trade checks, OFAC sanctions screening, scholarly papers, utilities and fixed-purpose language tasks (OCR, translate, summarize, extract, classify, prompt-injection check, transcribe). Pay per call in USDC. No accounts, no subscriptions, and no API key needed (prepaid keys are optional, for bots that cannot pay x402).

AgentFeed sells live trading data through the x402 payment protocol on Solana, Base, Polygon, Arbitrum, Arc, Algorand, Optimism, Monad and Avalanche, and on request on Celo, HyperEVM, Unichain, Scroll, SKALE Base, BNB Chain, Ethereum, Robinhood Chain, World Chain, Sei and X Layer (GET /api/<route>|<network>). An agent hits an endpoint, gets a 402 Payment Required with the price, pays a fraction of a cent in USDC (or the dollar token the network names) from its own wallet, and receives the data — in about two seconds, gas sponsored by the facilitator.

Two rails, same data:

---

What makes this different: the liquidation tape

We run our own liquidation collector across Bybit, OKX and Binance — every USDT-margined perpetual on all three, recorded continuously since 2026-07-08.

The size of that tape is not a claim, it is a query. Measured 2026-09-28 06:56 UTC:

It grows while you read this: the row count above and the one you get from the same query five minutes later will not match.

The 7-day figure is published live by the service itself at / under coverage.perp_markets_7d, recomputed from the tape rather than restated, so this README can be checked against it rather than believed.

This data cannot be bought. Not from us, not from anyone:

• Binance deleted their liquidation archive. liquidationSnapshot no longer exists on data.binance.vision — the directory is an empty shell. Verified 2026-07-12.
• Bybit has never published historical liquidation data.
• OKX offers a 7-day rolling REST window and nothing more.

There is no public historical liquidation dataset for any major venue, at any price. The only way to hold this data is to have been recording it.

And here is exactly where our data is weak

Being straight about this matters more than the marketing:

Binance and OKX rows are a structural undercount, and the undercount is worst during cascades — exactly when the data matters most. This is true of every liquidation dataset on the market, including the well-known ones. Most don't say so.

Bybit rows are the highest-integrity part of the dataset. Weight accordingly.

The side field, which most datasets get wrong

Three exchanges, three conventions. We normalize all of them:

• Bybit S is already the position side (Buy = a long was liquidated). Passed through.
• Binance S is the order side — a SELL order is what closes a long. Flipped.
• OKX exposes posSide explicitly. Mapped.

In our output: Buy = a LONG was liquidated. Sell = a SHORT was liquidated. Invert this and every long/short ratio you compute is backwards for some venues.

Notional uses filled_qty × avg_fill_price — what actually executed — not limit_price × requested_size.

---

Price index

Every paid route, cheapest question last. Generated from /.well-known/x402.json, read 2026-10-18 — names, prices and routes are the manifest's, not a copy kept in sync by hand. What each one returns is under 90 tools, word for word as the service publishes it.

Two payment protocols on one 402

Every paid route answers 402 with an x402 v2 challenge in the PAYMENT-REQUIRED header, and the same challenge as an x402 v1 body ({x402Version: 1, accepts}) for Base and Solana. Pay with PAYMENT-SIGNATURE (v2, any rail) or X-PAYMENT (v1 on Base or Solana, verified and settled through the CDP facilitator's v1 kinds; Polygon and Arbitrum have no v1 kind there and stay v2). Nine networks are in every 402 and eleven more are offered on request (see "Pay on any chain"). Each network is settled by exactly one facilitator: CDP for Solana, Base, Polygon, Arbitrum and World Chain; Circle's Facilitator Service for Arc, to a dedicated Arc address; GoPlausible for Algorand; Ultravioleta for Optimism, Monad, Avalanche, Celo, HyperEVM, Unichain, Scroll, SKALE Base, BNB Chain, Ethereum and Robinhood Chain; PayAI for Sei and X Layer. payments.js gives each facilitator client only its own networks, so a payment on one network can never reach another's facilitator. Every paid route also carries MPP tempo/charge challenges in WWW-Authenticate (Tempo mainnet, chain 4217, OUSD first, then USDC.e, at the route's price; no fee payer, the payer pays gas). Only signed transactions (pull mode) are accepted: the server validates the transfer, runs the request, and broadcasts it only when the response is below 400, so a failed call is never charged; an already-broadcast hash credential is refused. /api/sol-price and /api/btc-price additionally carry an MPP solana/charge challenge. All of them ride the same response, so a client settles with whichever protocol it speaks. The two live in disjoint header namespaces, so an x402-only client never sees the MPP one and is unaffected.

$ curl -si https://x402.ochinimus.app/api/btc-price      # 2026-09-23 09:18:09 UTC

HTTP/2 402
payment-required: eyJ4NDAyVmVyc2lvbiI6MiwiZXJyb3IiOiJQYXltZW50IHJlcXVpcmVkIiwi…
www-authenticate: Payment id="T0-lA4BfXXpf3GvzGklT8YobRJwSlEu8AXu9ZLz5VOg",
                  realm="x402.ochinimus.app", method="solana", intent="charge",
                  request="eyJhbW91bnQiOiIxMDAwIiwiY3VycmVuY3ki…",
                  expires="2026-09-23T09:23:09.919Z", opaque="eyJfbXBweF9zY29wZSI6…"

Base64-decoded, that MPP request is the whole quote:

{
  "amount": "1000",
  "currency": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
  "recipient": "4a8o45skRPcyjAdyR8yES215Swvh8uTpZD6KLarhxCJ7",
  "methodDetails": {
    "decimals": 6,
    "network": "mainnet",
    "recentBlockhash": "6e6NEAxddHca5ipHioSwZRhcGcSL4rW4q18AYszfnxyv",
    "tokenProgram": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
  }
}

Note what is not there: no feePayer. The client pays its own transaction fee and the server holds no funded signing key, which is the difference between the MPP challenge and the Solana x402 one sitting beside it in the same response.

Replay is refused, not merely discouraged. A settled signature is claimed atomically in SQLite before the resource is served, so two processes racing the same credential produce exactly one 200 and one refusal — covered by tests that fork real worker processes rather than stubbing the race.

The layer is fail-soft by design. If it cannot initialise it logs [mpp] DISABLED: <cause> and the service keeps serving x402 on every route rather than taking the paid surface down with it. Which routes are gated is published live at / and in /.well-known/x402.json under mpp.routes, so the advertised set is always whatever is actually mounted.

AgentFeed is one of several merchants accepting MPP on Solana mainnet — the Foundation's own Google proxy and smartmoney-market in solana-foundation/pay-skills do too.

Upstream work this produced

The pay-kit fix ships here as mpp/patches/@solana+mpp+0.7.0.patch, applied by patch-package on install and asserted by npm run verify-patch — the patch is a production dependency, not a dev one, because a --omit=dev install would otherwise complete silently unpatched.

Half price for high-frequency callers

A bot that calls often pays half the route's price, minimum $0.0005, through either of two schemes that ride the same 402 as the per-call accepts. Per-call prices do not change. The six prepaid-key purchase routes carry per-call accepts only. The Gateway accept is offered on Arc only: it was withdrawn from Base, Polygon and Arbitrum on 18 Oct 2026, because buyers whose client picked it as the cheapest accept of the chain signed a plain USDC authorization to the Gateway wallet, which is not a Gateway payment and was refused.

A call that answers 400 or more is never charged on either scheme.

batch-settlement, on Base

import { privateKeyToAccount } from 'viem/accounts';
import { createPublicClient, http } from 'viem';
import { base } from 'viem/chains';
import { BatchSettlementEvmScheme } from '@x402/evm/batch-settlement/client';
import { wrapFetchWithPaymentFromConfig } from '@x402/fetch';

const account = privateKeyToAccount(process.env.EVM_KEY);
const pub = createPublicClient({ chain: base, transport: http() });
const signer = Object.assign(account, { readContract: (args) => pub.readContract(args) });
const pay = wrapFetchWithPaymentFromConfig(fetch, {
  schemes: [{ network: 'eip155:8453', client: new BatchSettlementEvmScheme(signer) }],
});

// the first call opens the channel (one EIP-3009 authorization, no ETH needed); the rest are vouchers
for (let i = 0; i < 5; i++) {
  const res = await pay('https://x402.ochinimus.app/api/eth-price');
  console.log(res.status, await res.json());
}

Keep the pay object alive between calls. A client that starts a fresh process for every call is asked once to resync while vouchers are outstanding, and is then served in the same request.

Full script, with a guard that checks the accept before anything is signed: ops/proof-batch.mjs.

Gateway, on Arc

The Gateway accept is on Arc only (see "Pay on Arc" below for the full walk-through): ops/proof-gateway.mjs (CHAIN=arc, the default) deposits into the GatewayWallet once and pays one nanopayment.

Proven on mainnet

• 13 Oct 2026, batch-settlement on Base: a channel opened with deposit 0x6175…4492, ten 0.0005 USDC vouchers, claimed and settled to the treasury; a second run paid 8 calls while the claim job ran.
• 13 Oct 2026, Gateway on Arc: see "Pay on Arc" below.

All of them were paid from our own test wallets.

Pay on Arc

Every paid route takes USDC on Arc mainnet (eip155:5042, USDC 0x3600000000000000000000000000000000000000, 6 decimals) in two ways. Both sit in the same 402 as the other rails (the prepaid-key purchase routes offer the exact one only), so a client pays with whatever it holds. Gas on Arc is paid in USDC, so a buyer needs nothing else.

One call: x402 exact

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

const account = privateKeyToAccount(process.env.ARC_KEY);
const pay = wrapFetchWithPaymentFromConfig(fetch, {
  schemes: [{ network: 'eip155:5042', client: new ExactEvmScheme(account) }],
});
const res = await pay('https://x402.ochinimus.app/api/liquidation-stats');
console.log(res.status, await res.json());

Full script: ops/pay-arc.mjs.

Many calls: Gateway nanopayments

import { GatewayClient } from '@circle-fin/x402-batching/client';

const client = new GatewayClient({ chain: 'arc', privateKey: process.env.ARC_KEY });
await client.deposit('0.02'); // once: approve + deposit, gas paid in USDC
const res = await client.pay('https://x402.ochinimus.app/api/liquidation-stats');
console.log(res.formattedAmount, res.data);

Full script, with a deposit sized from a live gas estimate and a dry run: ops/proof-gateway.mjs (CHAIN=arc).

Proven on mainnet

• 12 Oct 2026, x402 exact through Circle's facilitator: 0x15e8…41d0
• 13 Oct 2026, Gateway deposit 0xffe7…9d50, then a 0.0005 USDC nanopayment (Circle transfer d32e4ea9-2d62-4fd6-ad4c-6de70affba00)
• 14 Oct 2026, x402 exact through Circle's facilitator with the production key: 0xee59…bf33, a 0.001 USDC call to /api/eth-price, status ok

All of them were paid from our own test wallets.

Where it lives in the code

• lib/rails.js: the Arc rail (network, asset, payTo).
• lib/circle-arc.js: the Circle Facilitator Service client: Arc-only /supported, /verify, /settle and settlement-status polling. A payment still pending is withheld and logged for ops/arc-reconcile.js.
• lib/hf.js: the half-price tier: batch-settlement on Base, Polygon and Arbitrum, the Gateway offer on Arc, the half-price rule, and routeGateway, which hands Gateway payments to Circle's BatchFacilitatorClient while every other payment keeps its facilitator.
• ops/batch-claim.js: claims and settles batch-settlement vouchers every 30 minutes.
• payments.js: facilitator order: Coinbase CDP first, Circle for Arc, then the Gateway tier.
• ops/gateway-withdraw.mjs and ops/arc-sweep.mjs: revenue out of the hot addresses.
• test/arc.test.js.

Pay on any chain

Nine networks are in every paid route's 402; eleven more are offered on request. Ask for one by suffixing the route: GET /api/<route>|<network> (the | may be sent as %7C), for example /api/sol-price|eip155:42220 for Celo. The 402 that comes back carries the default accepts plus that network's accept, and a payment on any network is accepted on the plain URL too. The prepaid-key purchase routes carry the nine only. The first six networks (Solana, Base, Polygon, Arbitrum, Arc, Algorand) are described under "Two payment protocols on one 402" and "Pay on Arc"; the table lists the other fourteen, generated from lib/ext-rails.js. Every row is scheme: exact (EIP-3009), paid to the same EVM treasury, settled by the one facilitator named in the row.

The token is not USDC everywhere: BNB Chain settles AUSD, Robinhood Chain USDG and SKALE Base USDC.e. Sei and X Layer are offered only on routes priced $0.005 or more, because PayAI charges per settlement.

Paying with @x402/fetch

@x402/fetch 2.28 refuses any token outside @x402/evm's DEFAULT_ASSETS unless the client opts in with spendControls.allowedAssets. Out of the box a stock client pays Monad, Avalanche, Celo, Ethereum and Sei. It is refused on Optimism, HyperEVM, Unichain, Scroll, SKALE Base, BNB Chain, Robinhood Chain, World Chain and X Layer until the token is allowed. The option shape, from @x402/core's own type definitions:

spendControls?: {
  maxAmountPerPayment?: Money | false;                 // USD cap on default assets, default "$1"
  allowedAssets?: true | SpendControlAsset[];          // true allows any asset
}
interface SpendControlAsset {
  network: Network;                                    // CAIP-2, e.g. 'eip155:10'
  asset: string;                                       // on-chain token address, or a default-asset symbol
  maxAmountPerPayment?: string;                        // integer atomic units, e.g. '50000' = $0.05 at 6 decimals
}

A payment on Optimism, with the token allowed explicitly (the cap '50000' is $0.05; the token is the address in the table):

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

const account = privateKeyToAccount(process.env.EVM_KEY);
const pay = wrapFetchWithPaymentFromConfig(fetch, {
  schemes: [{ network: 'eip155:10', client: new ExactEvmScheme(account) }],
  spendControls: { allowedAssets: [{ network: 'eip155:10', asset: '0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85', maxAmountPerPayment: '50000' }] },
});
const res = await pay('https://x402.ochinimus.app/api/sol-price');
console.log(res.status, await res.json());

Without the spendControls line the same client throws "All payment requirements were rejected by spendControls". Full script, with a dry run that prints the accept before anything is signed: ops/r10-proof-evm.mjs.

Proven on mainnet

• 14 Oct 2026, three proof payments of 0.001 USDC on /api/sol-price|<network>, each one USDC transfer from our test wallet to the treasury: Optimism 0xdc64…d4c5, Monad 0xdf06…da2d, Avalanche 0x5c3e…70d0.
• The other eleven networks are offered on request and have no settled payment yet.

All of them were paid from our own test wallets.

90 tools (83 paid data routes + 7 free) & pricing

83 paid + 7 free, 90 total on the MCP rail (the eight prepaid-key routes below are HTTP only). Every call is metered individually in USDC over x402 — no bundles, no minimums. Calling all 83 paid data tools once costs $1.137. Counts and prices are summed from the live manifest, read 2026-10-15.

The flagship is get_squeeze_score — a 0-100 short-squeeze / long-flush composite built from funding, crowding, OI build and the liq-skew of our exclusive tape. One number, one dime, answers "is this trade crowded and about to hurt someone."

The moat — our own liquidation tape

The second moat — our own tokenized-equity peg tape

Sampled every 5 minutes. Deviation is measured against the underlying's last real trade — outside US market hours that is the last print before the close, not a live quote. Dead pools are excluded rather than reported as perfect pegs.

The third moat — our own collateral exit-liquidity tape

Live liquidations & cascades

Derivatives

Microstructure

Market & positioning

Solana on-chain

Base / EVM

| get_honeypot_check | $0.01 | /api/honeypot-check | Use when an agent needs to know whether a token on Base, BNB Chain or Ethereum can be sold before it buys. Returns a verdict from our own buy-then-sell simulation on the token's deepest pool, with the buy and sell tax measured. Also: whether a wallet transfer works, bytecode flags (mintable, blacklist, proxy, pausable, owner), where simulation and bytecode disagree, and the block. Uniswap, Aerodrome and PancakeSwap pools. No pool found is a finding; RPC failure answers 503. | | get_base_launches | $0.02 | /api/base-launches | Use when an agent needs the newest token launches on Base. Returns pools created on Base in the last 24 hours on Uniswap V4, V3, V2 and Aerodrome, newest first, with launchpad, liquidity and volume. Each carries its pair, creation time, launchpad named from the V4 hook (Zora, Clanker, Doppler, Flaunch), quote-side liquidity, 24h volume and swaps, and our honeypot simulation for the busiest. Read from Base logs every minute; a snapshot older than 5 minutes answers 503. |

Filings, documents & web

Macro

TradFi perps & stocks

Research, compliance & utilities

Sources and their terms: the OFAC SDN list (a US federal government work), the CC0 disposable-email-domains list, DNS and a live TLS handshake, OpenAlex (CC0 data), Wikipedia (CC BY-SA 4.0, attribution in every answer); details in docs/SOURCES.md.

Language tasks (fixed-purpose, Gemini)

Each one is a single fixed task on Google's Gemini API (paid tier): the caller supplies content, never a prompt, model or setting. Untrusted content travels as delimited data, every output is schema-checked, and a provider failure is a 503 that is never billed. These seven are available only to callers inside Google's available regions: elsewhere they answer 451 before any payment.

Signals for trading bots

Both read only data this service records itself (the Hyperliquid OI sampler, the liquidation tape, the whale snapshot) and name every source with its as_of; a stale source answers 503 and is never billed. With a prepaid key they cost $0.005 and $0.002.

Liquidation pressure feed for bots

GET /api/liq-feed is cross-venue liquidation pressure, computed by AgentFeed from its own liquidation recording and served the way a bot polls: 5-second buckets, a cursor that never skips and never repeats, and a floor price.

• What a row is. One row per symbol per closed 5-second bucket that held a liquidation: longs and shorts (USD, base quantity and VWAP of the long and the short positions liquidated, all venues combined into one figure), dominant (longs, shorts or balanced: the side holding at least 60% of the bucket) and pressure (the bucket's USD against the symbol's own typical USD per 5 seconds, its median hour of the last 7 days floored at $5,000 an hour). Numbers are rounded to 2 significant figures (3 for the VWAP) and no count of prints is returned.
• The cursor. Send since=<ms> once (up to 24 h back; without it the first call begins 2 minutes back), then send each answer's next back unchanged. A bucket is served only after it has been closed for 10 seconds, every closed bucket is served exactly once, and has_more tells you to ask again at once. Up to 20 symbols and 500 rows a call (symbols=BTC,ETH,SOL, or BTC-USDT style).
• What it costs a bot. $0.001 a call over x402, $0.0005 on a prepaid key. One call every 5 seconds (one bucket) per caller, an x402 payer or a prepaid key, and every 10 seconds for a pass key (a refused poll is a 429 with Retry-After, never billed; a call that follows an answer saying has_more is exempt). A key has the same single clock over REST and over the MCP tool get_liq_feed; an x402 payer is keyed by IP over REST and by paying wallet over MCP. The horizon moves in 5-second steps, so a call sooner than that could not carry a new bucket. At the 5-second floor that is 17,280 calls and $8.64 a day on a key; at a 30-second poll 2,880 calls and $1.44 a day; at 60 seconds, $0.72. A bot pass ($25 flat for 30 days, this route only) is $0.83 a day at any poll rate.

curl -s -H "X-AgentFeed-Key: $AGENTFEED_KEY" \
  "https://x402.ochinimus.app/api/liq-feed?symbols=BTC,ETH,SOL&since=$(( $(date +%s) * 1000 - 300000 ))"

Free tasters

Seven, of which four have an HTTP route — those four are the ones published at / under free_tools. The other three are MCP-only and have no paid HTTP equivalent to undercut.

Two more free HTTP endpoints carry no tool of their own:

A free route answers "paid": false, and a paid one "paid": true, because that field is per-request: it reports whether the route you called is priced. curling either of the two above costs nothing and says so.

Use it from an elizaOS agent

npm i @seekdaseek/plugin-agentfeed   # one action per data route; the current version is on npm

Set AGENTFEED_PRIVATE_KEY to a funded Solana wallet and the agent pays per call automatically. Default spend cap $0.50/call (AGENTFEED_MAX_SPEND_PER_CALL to change).

Try it free right now

curl https://x402.ochinimus.app/api/fear-greed       # "paid": false — it really is free
curl https://x402.ochinimus.app/api/last-liquidation
curl https://x402.ochinimus.app/api/exit-method
curl https://x402.ochinimus.app/                    # full pricing index + live coverage
curl https://x402.ochinimus.app/api/cascade-scan    # returns 402 + payment terms

x402 clients pay and retry automatically.

Prepaid keys (for bots that cannot pay x402)

A bot that can set an HTTP header but cannot sign an x402 payment (n8n, Freqtrade, Hummingbot, a plain script, a gateway such as claw402) buys a key once and spends it per call.

• Buy once, with any x402 client, on any exact rail the route offers: GET /api/keys/buy-trial ($0.25), buy-1, buy-5, buy-20. Top up with topup-5 or topup-20, sending the key as the header. Or in a browser at /keys with a Base wallet: the page loads no library and sends nothing but the key's hash.
• Spend per call: send X-AgentFeed-Key: afk_... (or Authorization: Bearer afk_...) on any paid GET or on POST /mcp. Each call draws half the route's x402 price, minimum $0.0005, from the balance; a 400, 404, 500 or 503 is never drawn. 120 requests per minute per key.
• Bring your own key: generate afk_ + base58 of 32 random bytes yourself and buy with ?key_hash=<sha256 hex>&prefix=<8 characters after afk_>; the server registers the hash and never sees the key, and a dropped connection after payment loses nothing. Without key_hash the server generates the key and returns it once.
• Bot pass: GET /api/keys/buy-pass ($25) is a different kind of key for a bot that polls /api/liq-feed all day: valid for 30 days from the moment its payment settles, good only on /api/liq-feed (and the MCP tool get_liq_feed), nothing drawn per call, still one call per 10 seconds. Every other route answers 403 to it, it cannot be topped up, and GET /api/keys/balance shows its routes and expiry. At a 30-second poll it costs $0.83 a day, against $1.44 a day on an ordinary key.
• Day pass: GET /api/keys/buy-day-pass is $1.00 flat for 24 hours from the moment its payment settles, good only on /api/liq-feed and /api/liquidations, nothing drawn per call, each of the two routes one call every 10 seconds per key (6 a minute; a call inside the 10 seconds is a 429 with Retry-After, never billed). It is the pass a default x402 client can buy as it is: @x402/fetch 2.28 refuses any payment over $1 before signing and accepts exactly $1.00 (measured), so the $5 and $20 packs and the $25 bot pass need spendControls raised and this one does not. Every other route answers 403 to it, it cannot be topped up, and GET /api/keys/balance shows its routes, expiry and hours left. Also in the browser at /keys.
• Balance: GET /api/keys/balance with the header, free.
• Terms: a prepaid balance is usage credit, non-refundable, with no expiry (a bot pass is a flat price, non-refundable, valid for 30 days, and the day pass the same for 24 hours); the key is a bearer secret (anyone holding it spends the balance); abuse means revocation. Purchase routes offer the exact accepts only, because credit bought through the half-price batch or Gateway tier would be a free 50%.
• In the books: a purchase is a settled payment (status paid); the calls it funds are rows of status key, consumption of credit already counted, never revenue.

No wallet? Use Apify Store

Five AgentFeed data sets are also Apify Store actors. The Store bills in fiat through Apify, so no wallet is needed.

Prices are per result, plus Apify's $0.00005 start fee per run.

Use AgentFeed in NOFX

NOFX is an open-source AI trading terminal. get_signal_board and get_coin_signal are shaped for its External Data Sources: data.coins is an object keyed by coin in open-interest order, data.ranked is the list, data.sources names each source, and the board is about 10 KB for 30 coins. Read this first: at NOFX commit ef476f2 nothing calls the function that fetches External Data Sources (StrategyEngine.FetchExternalData), so stock NOFX saves the two entries and never reads them into a prompt; they work on a NOFX build that calls it, and the same key works from anything else that sends a header. docs/nofx.md (中文) has the exact strategy JSON, how to buy a key from the wallet NOFX already pays claw402 with, the cost per trader (about $0.48 a day for the board and $0.19 a day per coin at NOFX's default 15-minute scan) and the proof harness that replays NOFX's fetch and data_path walk against the live routes.

Pay for a call

Copy payTo only from a fresh 402 response, never from transaction history. On 2026-07-31 a lookalike of the Base treasury (same first and last characters as 0x22DB…76e6) sent zero-value address-poisoning transfers to our biggest buyer, so a wallet's history can show a fake payee next to the real one.

x402 — the client that ships in this repo

test-client.mjs is the repo's own Solana x402 payer: @x402/svm's ExactSvmScheme behind wrapFetchWithPaymentFromConfig, reading a standard solana-keygen 64-byte JSON keypair.

node test-client.mjs https://x402.ochinimus.app/api/sol-price ./payer-wallet.json

test-client-evm.mjs is the same thing over Base (eip155:8453) with a viem account, and test-mcp-client.mjs pays MCP tool calls over Streamable HTTP. Settlements land in the audit table with the payer and the transaction signature; the last run of this client from the project's own payer GBFoGJXvLsgBXAKJw9cGK18BGxaevpYtAyQKoqgcSQKz settled 4ixeZSHSYcBcx5PhRDvPbLwMY2Vgj24FPkjnCaBkewhfcva2kHj32suXv7UE2M4NGsh4q31yGJRqx5nvqbBLNxvD.

MPP — the Foundation's pay CLI

pay --mainnet --mpp --account <account> curl -s https://x402.ochinimus.app/api/btc-price

Two MPP payments settled against this service on 2026-09-19, at 21:53:39 and 21:57:36 UTC, and both signatures are recorded in the replay store so neither can be spent twice.

The pay CLI needs an interactive session. An account with auth_required: true blocks on a Touch ID prompt that cannot render in CI, a headless agent or a scheduled task, and it blocks without a timeout — it looks exactly like a network hang while holding zero TCP sockets. That is solana-foundation/pay #469. Run it from a real GUI session, or use an account without auth_required.

MCP quickstart

Point any MCP client at https://x402.ochinimus.app/mcp (Streamable HTTP, POST). Paid tools return payment terms; an x402-capable client settles and retries.

createx402MCPClient is exported by the published @x402/mcp (checked against the npm tarball, 2.27.0, 2026-09-23). This is what test-mcp-client.mjs in this repo actually does:

import { createx402MCPClient } from '@x402/mcp';
import { ExactSvmScheme } from '@x402/svm/exact/client';
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';

const client = createx402MCPClient({
  name: 'agentfeed-test',
  version: '1.0.0',
  schemes: [{ network: 'solana:*', client: new ExactSvmScheme(signer) }],
  autoPayment: true,
});

await client.connect(new StreamableHTTPClientTransport(new URL('https://x402.ochinimus.app/mcp')));
const { tools } = await client.listTools();
const result = await client.callTool('get_sol_price', {});   // pays and retries

Also available as an elizaOS plugin.

---

Configuration

Every variable the service reads, derived from the source (grep -rhoE "process\.env\.[A-Z0-9_]+"). Only HELIUS_API_KEY, PAY_TO and — when MPP is on — MPP_SECRET_KEY have no working default.

DB_PATH, SIGNATURE, VERIFY_DELAY_MS, HOME and PATH appear only in the MPP test harness (mpp/test/helpers/) and are not service configuration.

Tests

npm install
cd mpp && npm install && cd ..    # separate tree: mppx pins express>=5, this service is express 4

node --test test/tool.test.js     # 10 tests — the route wrapper and the `paid` flag
node --test mpp/test/*.js         # 40 tests — MPP conformance, offline, every RPC call stubbed

Neither package.json declares a test script; the commands above are the ones the test files themselves document.

test/tool.test.js mounts the real wrapper from lib/tool.js — the same module server.js mounts, not a copy — on a throwaway express app over a real socket, so req.route is populated exactly as in production. It covers a priced route, a path-parameter route (which is what proves the flag matches on the registered pattern and not the request URL), an unpriced route that is nonetheless registered with a price argument, X402_MODE=off, the audit row's field set on success / error / bad_request, and prototype pollution through req.route.path.

Two of the MPP tests fork real worker processes to race the replay store across process boundaries rather than simulating the race in one event loop.

---

Free dataset

A multi-venue liquidation dataset — normalized, growing daily, free — ships with a full quality statement covering coverage dates, known gaps, exchange throttles, and field definitions: ochinimuse.gumroad.com/l/liqdata

Read DATASET_QUALITY.md before you use it. It tells you exactly where the data is wrong.

---

Links

MCP Registry · Smithery · x402 manifest · ochinimus