# Grey Ridge Signals — MCP security scanning & on-chain data APIs

> Two ways to use us. HUMANS & TEAMS: scan any MCP server for prompt-injection / tool-poisoning (OWASP LLM01/LLM08) in your browser — free, read-only — and subscribe by card ($9.99/mo) to gate CI and get continuous re-scans. No wallet, no crypto. AGENTS: the same endpoints are agent-native, pay-per-call on Base (USDC via x402) — no account, no API key, pay inline.
> Scan a server (free): https://x402-data-api.sigrunner.workers.dev/scan/mcp-scanner  |  Subscribe (card): https://x402-data-api.sigrunner.workers.dev/pricing  |  Landing: https://x402-data-api.sigrunner.workers.dev/  |  Agent discovery: https://x402-data-api.sigrunner.workers.dev/.well-known/x402  |  OpenAPI: https://x402-data-api.sigrunner.workers.dev/openapi.json

## For humans & teams — scan your MCP server, pay by card (no wallet)
If you build, ship, or operate MCP servers and tools, this is the fast path — no crypto required.
- Scan free, in your browser: https://x402-data-api.sigrunner.workers.dev/scan/mcp-scanner — paste your server's `tools/list` (private/local servers never leave your side) or scan a public server by URL. Instant verdict: clear | review | block, with the exact injected text and which tool carries it.
- Per-server trust report (shareable, crawlable): https://x402-data-api.sigrunner.workers.dev/scan/report?url=<your-mcp-server> — point-in-time injection verdict plus a live manifest-drift read, one page.
- Deep verified badge for YOUR x402 endpoint (free, embeddable, re-audits live): https://x402-data-api.sigrunner.workers.dev/x402/badge?url=<your-endpoint> — returns the shields.io endpoint schema, so `![x402 verified](https://img.shields.io/endpoint?url=https://x402-data-api.sigrunner.workers.dev/x402/badge%3Furl%3D<encoded>)` shows buyers a live third-party verdict that re-runs on every render and flips colour when your endpoint degrades. Certifies the DEPTH axis a liveness-only badge cannot: advertised-vs-charged price accuracy, delivery readiness, LLM01/LLM08 injection safety, and payTo OFAC/scam screening. Add &detail=1 for the full tier breakdown. The machine-readable report is at https://x402-data-api.sigrunner.workers.dev/x402/preflight ($0.001).
- Deep verified CERTIFICATE for YOUR x402 endpoint (paid, $1 USDC, no account): https://x402-data-api.sigrunner.workers.dev/x402/cert?url=<your-endpoint> — pay once inline with x402 and, if the full deep audit passes, get a dated, HMAC-signed 30-day certificate persisted and served as a certified badge (`![x402 deep-certified](https://img.shields.io/endpoint?url=https://x402-data-api.sigrunner.workers.dev/x402/cert/badge%3Furl%3D<encoded>)`) that re-audits live on every render and flips to "degraded" the moment your endpoint breaks before expiry. Unlike a liveness-only verified badge, this certifies price ACCURACY, delivery readiness, LLM01/LLM08 injection safety and payTo OFAC/scam screening — and any buyer re-checks the signature free at https://x402-data-api.sigrunner.workers.dev/x402/cert/verify?id=<cert_id>. Fails honest: no certificate unless the audit returns PAY (you get the findings + fix hints instead). Free preview: https://x402-data-api.sigrunner.workers.dev/x402/cert/preview.
- Repeat-demand check — do an x402 endpoint's payers come BACK? (paid, $0.004): https://x402-data-api.sigrunner.workers.dev/x402/repeat-demand?url=<endpoint> (or &payto=<0x>). Liveness, price-accuracy and OFAC tell you an endpoint is SAFE to pay — none tell you it was WORTH paying. This reads the only on-chain repeat-value signal: it scans every incoming USDC settlement to the endpoint's advertised payTo on Base, groups by payer, and returns distinct_payers vs repeat_payers + repeat_rate + gross + first/last seen. Verdict REPEAT_DEMAND | SINGLE_USE | NO_SETTLEMENTS. Use it to pick, from two endpoints that both pass preflight, the one real agents keep paying. Honest: for a dedicated x402 payTo the inflow == its paying agents (a shared/treasury wallet overcounts, disclosed); lower bound. Free preview (3/IP/day): https://x402-data-api.sigrunner.workers.dev/x402/repeat-demand/preview.
- Payer roster + concentration — WHO pays an x402 endpoint (paid, $0.001): https://x402-data-api.sigrunner.workers.dev/x402/clients?url=<endpoint> (or &payto=<0x>). repeat-demand tells you IF payers return; this tells you who they ARE and whether a headline settlement count is broad demand or one whale. Scans incoming USDC settlements to the endpoint's advertised payTo on Base, groups by payer, and returns the per-wallet roster (payments + gross + share + first/last seen + is_repeat) plus a concentration block (top_payer_share + Herfindahl HHI -> effective number of payers). Verdict DISTRIBUTED | CONCENTRATED | SINGLE_PAYER | NO_SETTLEMENTS — CONCENTRATED flags volume inflated by one dominant wallet (self-wash or a captive integration, not organic breadth). &limit=1-100 (default 20). Honest: dedicated payTo => roster == paying agents (shared wallet overcounts, disclosed); lower bound. Free preview (3/IP/day): https://x402-data-api.sigrunner.workers.dev/x402/clients/preview.
- Subscribe by card — $9.99/mo: https://x402-data-api.sigrunner.workers.dev/pricing. Gives you an API key for 100 scans/month across any Grey Ridge endpoint, so you can gate your CI (fail the build on `block`) and re-scan continuously. Card only — no wallet, no USDC, no on-chain anything. Checkout is Stripe; your key is shown on the success page and at https://x402-data-api.sigrunner.workers.dev/api-key.
- CI gate (GitHub Action): `uses: rezearcher/greyridge-x402-tools@v0.3.2` — on the GitHub Marketplace (https://github.com/marketplace/actions/mcp-server-tool-poisoning-scan); runs the scan on every push and fails the build on a `block` verdict.
- Why this and not a free token checker: token-safety has free multi-chain scanners; MCP tool-poisoning / prompt-injection detection does not. This is the differentiated, paid-worthy lane.

## For security & platform teams — hands-on assessments (engagement, not per-call)
When a static scan isn't enough — a live agent deployment, permission and auth boundaries, secret handling, on-chain approval and slippage exposure — Grey Ridge Signals runs scoped security assessments.
- Service page: https://x402-data-api.sigrunner.workers.dev/security-assessment — fixed-scope assessment of MCP servers, agents, or on-chain integrations ($7,500–$15,000 per engagement) and continuous monitoring retainers ($3,000–$5,000/mo).
- What it covers: tool poisoning and prompt injection (OWASP LLM01), excessive agency and over-scoped tools (LLM08), data exfiltration, cross-tool shadowing, invisible-unicode / variation-selector smuggling, ANSI and CSS covert channels, auth and secret handling, on-chain approval exposure — static plus live behavioural testing and manual review.
- Deliverable: a severity-scored findings report with reproduction and remediation, an executive summary, and a free re-test after fixes ship.
- Authorized testing only: we test solely the assets you own or explicitly authorize. Scope and authorization are fixed at a scoping call before anything is tested.
- Start: contact@greyridgesignals.ai or the intake form at https://x402-data-api.sigrunner.workers.dev/security-assessment. Payment is by invoice, not crypto.

## How to pay — first paid call in ~8 lines (copy-paste, verified)
Each paid GET returns HTTP 402 with an x402 v2 challenge (network eip155:8453 / Base, asset USDC, 6 decimals). The standard x402-fetch client signs + retries for you — no account, no API key. Your wallet needs a little USDC on Base; no gas ETH (the exact scheme is EIP-3009 gasless — the facilitator submits). The 2nd arg to wrapFetchWithPayment is a viem WalletClient, not a bare account.

Hold USDC on another chain? The live 402 offers native USDC on Base, Polygon, Arbitrum (Base is accepts[0]; same payTo, same price) — pick whichever your wallet funds, your x402 client selects it automatically. Calling many routes in a loop and don't want a signature per call? Open a prepaid session cap ONCE over x402 — /x402/session ($0.05 cap), /x402/session/plus ($0.50 cap), /x402/session/max ($5.00 cap) — then pass the returned token as `Authorization: Bearer <token>` (or `X-Session-Token`) and paid routes debit the cap with no per-call signature. Open: POST https://x402-data-api.sigrunner.workers.dev/x402/session (pays the cap inline). Check remaining balance free: GET https://x402-data-api.sigrunner.workers.dev/x402/session/status.

  npm i x402-fetch viem
  import { createWalletClient, http } from "viem";
  import { privateKeyToAccount } from "viem/accounts";
  import { base } from "viem/chains";
  import { wrapFetchWithPayment } from "x402-fetch";
  const account = privateKeyToAccount(process.env.EVM_PRIVATE_KEY);
  const walletClient = createWalletClient({ account, chain: base, transport: http() });
  const pay = wrapFetchWithPayment(fetch, walletClient);
  const r = await pay("https://x402-data-api.sigrunner.workers.dev/gate/swap?token=0x4200000000000000000000000000000000000006&side=buy&notional_usd=500");
  console.log(await r.json());   // GO | HOLD | BLOCK — settles in ~1s, costs $0.008 USDC

Runnable version: https://github.com/rezearcher/x402-data-api/blob/main/examples/buyer.mjs (EVM_PRIVATE_KEY=0x... node examples/buyer.mjs). Python / Axios clients + full docs: https://x402.org buyer quickstart. Prefer to look before you pay? Every flagship route has a free, no-wallet /preview (same response shape) — see the Free section below.

Already run a generic x402 buyer adapter? This API is wire-compatible with OpenAPI-driven x402 MCP clients: our /openapi.json tags every billable route with x-billable/x-availability/x-price-usdc and honors ?preview=true on the paid path, and /.well-known/agent-capabilities.json?q=&limit=N returns ranked products whose operation_id resolves straight back to the OpenAPI operation. e.g. point the npm MCP adapter dopaminedesk-ai-data-marketplace-mcp at us with one env var — MARKETPLACE_URL=https://x402-data-api.sigrunner.workers.dev — to discover, preview, and buy Grey Ridge routes with no code change.

## Install as a drop-in tool for your framework (one line, pay inline over x402)
You run a framework, not raw HTTP — so install the data tools for it instead of hand-wiring calls. Each package pays inline in USDC over x402 (no account, no API key) and degrades to the free preview when unpaid:
- Any agent (Claude Code, Cursor, 79+ frameworks) — keyless skill, no login, no npm (Agent skill (SKILL.md)): `npx skills add rezearcher/x402-defi-data` — 4 tools wrapping /defi/yields, /defi/yield-entry-verdict, /crypto/funding, /crypto/prices. https://github.com/rezearcher/x402-defi-data
- Vercel AI SDK (TypeScript): `npm i github:rezearcher/vercel-ai-defi-data` — 11 tools wrapping /defi/yields, /crypto/prices, /crypto/funding, /brief/market, /chain/balance, /chain/gas-price, /chain/block-number, /chain/token-balance, /chain/token-report, /defi/yield-entry-verdict, /chain/simulate. https://github.com/rezearcher/vercel-ai-defi-data
- LangChain.js (TypeScript): `npm i github:rezearcher/langchain-defi-data` — 11 tools wrapping /defi/yields, /crypto/prices, /crypto/funding, /brief/market, /chain/balance, /chain/gas-price, /chain/block-number, /chain/token-balance, /chain/token-report, /defi/yield-entry-verdict, /chain/simulate. https://github.com/rezearcher/langchain-defi-data
- CrewAI / plain Python (Python): `pip install git+https://github.com/rezearcher/crewai-defi-data` — 11 tools wrapping /defi/yields, /crypto/prices, /crypto/funding, /brief/market, /chain/balance, /chain/gas-price, /chain/block-number, /chain/token-balance, /chain/token-report, /defi/yield-entry-verdict, /chain/simulate. https://github.com/rezearcher/crewai-defi-data
- LangChain / CrewAI / plain Python (PyPI) (Python): `pip install greyridge-x402-tools` — 5 tools wrapping /crypto/prices, /defi/yields, /crypto/funding, /chain/token-report, /gate/swap. https://github.com/rezearcher/greyridge-x402-tools
- Node / TypeScript — safeFetch preflight-pay-receipt wrapper (git install) (TypeScript): `npm i github:rezearcher/greyridge-x402-tools` — 2 tools wrapping /x402/preflight, /x402/receipt-verify. https://github.com/rezearcher/greyridge-x402-tools
- Node / TypeScript — drop-in @x402/fetch wrapper (git install) (TypeScript): `npm i github:rezearcher/x402-verified-fetch` — 1 tools wrapping /x402/receipt-verify. https://github.com/rezearcher/x402-verified-fetch
The same index is machine-readable in /.well-known/x402 (integrations.installable_tools) and /.well-known/agent-capabilities.json, so an agent can discover the install path for its own framework.

## Start here — two flagships (what agents actually pay us for)

### 1. MCP server security scan — prompt-injection / tool-poisoning audit (unique; no free equivalent)
Before your agent trusts an MCP server's tools, scan them for hidden-instruction / tool-poisoning attacks (OWASP LLM01/LLM08). Zero-egress by design: for private or OAuth-gated servers you POST only the tools/list JSON — nothing else leaves your side. Unlike token-safety (where free multi-chain scanners exist), there is no free equivalent for this.
- POST https://x402-data-api.sigrunner.workers.dev/scan/mcp — $0.05 — itemized findings (which tool, the injected text, remediation) + risk score + verdict clear|review|block. Body: {"tools":[…]} from your server's tools/list (or GET ?url=<public-mcp-server>).
- Free preview: POST https://x402-data-api.sigrunner.workers.dev/scan/mcp/preview with {"tools":[…]} → counts + severity + risk score + verdict (detail withheld). One-liner that pulls an auth'd server's tools/list over Streamable-HTTP: https://github.com/rezearcher/x402-data-api/blob/main/examples/mcp-scan-preview.sh
- CI gate: uses: rezearcher/greyridge-x402-tools@v0.3.2 — listed on the GitHub Marketplace (https://github.com/marketplace/actions/mcp-server-tool-poisoning-scan); runs the scan in CI and fails the build on a block verdict.

### 2. Pre-trade decision gate for Base trading agents — a decision, not raw flags
Raw honeypot-flag APIs make your agent interpret the flags; this returns ONE decision sized to YOUR trade. Base-native (Base ERC-20s) — if you trade other chains, keep your multi-chain scanner and use this where you're on Base.
- GET https://x402-data-api.sigrunner.workers.dev/gate/swap?token=<0x…>&side=buy&notional_usd=500 — $0.008 — GO|HOLD|BLOCK (honeypot/sellability + liquidity price impact vs your trade size). Free try: https://x402-data-api.sigrunner.workers.dev/gate/swap/preview?token=usdc|weth|cbbtc|aero|degen (any real Base 0x address: 3 free/day/IP).
- GET https://x402-data-api.sigrunner.workers.dev/chain/token-report?token=<0x…> — $0.01 — SAFE|CAUTION|AVOID + risk_score 0-100 + reasons. Free try: https://x402-data-api.sigrunner.workers.dev/chain/token-report/preview?token=aero

Measured uptime/latency of these (not an SLA): GET https://x402-data-api.sigrunner.workers.dev/status (live machine-readable JSON) or https://github.com/rezearcher/x402-data-api/blob/main/docs/STATUS.md
Proof pack for integrators (a real settled Base-mainnet x402 tx + decoded receipt, measured reliability, and accuracy stated honestly incl. what we have NOT yet benchmarked): https://github.com/rezearcher/x402-data-api/blob/main/docs/EVIDENCE.md
Our own payment hardening (the posture we hold to, and screen others for): every PAID response is returned non-cacheable — `Cache-Control: no-store` + `Vary: X-PAYMENT` keyed on the settlement header — so no shared/proxy/browser cache can replay a paid body to an unpaid client. That closes Attack III (HTTP/proxy cache-leakage) of the "Five Attacks on x402" taxonomy (arXiv 2605.11781); combined with on-chain receipt verification (/x402/receipt-verify), payment-identifier idempotency, pre-payment safety (/x402/preflight), and payTo OFAC screening, the rail answers all of M1–M6. And we screen OTHER endpoints for the same posture: /x402/preflight now returns an Attack-III cache_posture verdict (NO_STORE | CACHEABLE | OBSERVED_CACHED | UNKNOWN) on any x402 URL you pre-check — a shared cache actively storing a paid route trips CAUTION. Verify it yourself: a paid route's 200 carries `cache-control: no-store`, while a free /preview stays cacheable.

## Endpoints
- Human/agent try-it page: https://x402-data-api.sigrunner.workers.dev/check?token=<0x… Base ERC-20> — free verdict card (3/day/IP).
- GET https://x402-data-api.sigrunner.workers.dev/crypto/prices?coins=bitcoin,ethereum,solana — $0.001 — spot token prices + change_24h + unix timestamp (DefiLlama), keyless. Agentic buyer example with budget + freshness gates (reads the 402 quote before paying, rejects stale data): https://github.com/rezearcher/x402-data-api/blob/main/examples/market-data-decision-buyer.mjs
- GET https://x402-data-api.sigrunner.workers.dev/crypto/funding?limit=20 — $0.004 — 6-venue Binance+Bybit+OKX+Hyperliquid+dYdX+Gate funding rates + CEX↔DEX arb spread (bps) + best long/short venue + premium/annualized/signal/next_funding_ts.
- GET https://x402-data-api.sigrunner.workers.dev/defi/yields?limit=20&project=&chain=&stable=&sort=tvl|risk_adjusted — $0.001 — top DeFi lending/LP yields, APY trend + IL risk + reward/underlying tokens + mu/sigma + stability forecast + TVL (DefiLlama).
- GET https://x402-data-api.sigrunner.workers.dev/pm/markets?query=&limit=20 — $0.005 — live Polymarket prediction markets, ranked by volume24hr (bestBid/bestAsk/spread, clobTokenIds, category tags, liquidity).
- GET https://x402-data-api.sigrunner.workers.dev/scan/mcp?url=<mcp-server> — $0.05 — security audit of an MCP server (tool-poisoning / prompt-injection, OWASP LLM01/LLM08); findings + risk score + verdict (clear/review/block).
- GET https://x402-data-api.sigrunner.workers.dev/enrich/tech-risk?domain=<domain> — $0.01 — tech-stack -> CVE (NVD) + EPSS + CISA-KEV risk + verdict (clear/review/block).
- GET https://x402-data-api.sigrunner.workers.dev/enrich/domain?domain=<domain> — $0.01 — firmographic + tech-stack enrichment, incl. subdomain enumeration (crt.sh) + verdict (clear/review/block, domain age).
- GET https://x402-data-api.sigrunner.workers.dev/chain/block-number — $0.002 — current Base mainnet block number.
- GET https://x402-data-api.sigrunner.workers.dev/chain/gas-price — $0.002 — current Base mainnet gas price (wei/gwei), EIP-1559 base_fee_gwei/priority_fee_gwei, gas_price_usd — no price oracle on ETH-only competitors.
- GET https://x402-data-api.sigrunner.workers.dev/chain/balance?address=<0x…> — $0.002 — ETH balance of a Base address, incl. balance_usd.
- GET https://x402-data-api.sigrunner.workers.dev/chain/token-balance?address=<0x…>&token=<0x…> — $0.002 — ERC-20 token balance of a Base address, incl. symbol/decimals/balance_formatted.
- GET https://x402-data-api.sigrunner.workers.dev/chain/tx?hash=<0x…> — $0.005 — transaction details by hash on Base.
- GET https://x402-data-api.sigrunner.workers.dev/chain/receipt?hash=<0x…> — $0.005 — transaction receipt by hash on Base: status, gas used, full logs, L1 fee breakdown (l1_fee_wei/l1_gas_price_wei/l1_gas_used/effective_gas_price_wei) + l1_fee_usd/total_fee_usd.
- GET https://x402-data-api.sigrunner.workers.dev/chain/nonce?address=<0x…> — $0.002 — tx count (nonce), latest + pending.
- GET https://x402-data-api.sigrunner.workers.dev/chain/block?number=<n|latest> — $0.002 — block summary (hash, timestamp, tx count, gas, base fee).
- GET https://x402-data-api.sigrunner.workers.dev/ai/ask?q=<prompt> — $0.002 — cheap LLM answer (Llama 3.2 3B), no API key.
- POST https://x402-data-api.sigrunner.workers.dev/v1/chat/completions — $0.004 — OpenAI-compatible chat (Llama 3.3 70B, stream:true supported), no API key; point any OpenAI SDK base URL here with an x402 fetch wrapper. Free real-model try: POST https://x402-data-api.sigrunner.workers.dev/v1/chat/completions/preview (3/day/IP). Model list: GET https://x402-data-api.sigrunner.workers.dev/v1/models. Runnable buyer: https://github.com/rezearcher/x402-data-api/blob/main/examples/llm-chat.mjs — best fit as an ADDITIVE x402 fallback provider: wire it as your router's secondary/backup inference base URL so it only gets called when your primary provider times out, errors, or returns no text — you pay $0 until you actually need it (no price-war, no account, no API key; measured 99.92% uptime over 2518 samples). Reference implementation (one env var, byte-identical when unset): https://github.com/0xcuy/adexto/pull/5. Also drop-in for Daydreams / Lucid-Agents (model=llama-3.3-70b).
- GET https://x402-data-api.sigrunner.workers.dev/chain/erc20-meta?token=<0x…> — $0.002 — ERC-20 name/symbol/decimals/totalSupply.
- GET https://x402-data-api.sigrunner.workers.dev/chain/is-contract?address=<0x…> — $0.002 — contract vs EOA + bytecode size.
- GET https://x402-data-api.sigrunner.workers.dev/chain/fee-estimate — $0.004 — Base EIP-1559 fee tiers (slow/standard/fast) + transfer cost.
- GET https://x402-data-api.sigrunner.workers.dev/chain/network-status — $0.004 — Base chain id, latest block, block age, gas utilisation.
- GET https://x402-data-api.sigrunner.workers.dev/chain/l1-base-fee — $0.004 — Ethereum L1 base fee seen by Base's GasPriceOracle + L1 data-fee estimate.
- GET https://x402-data-api.sigrunner.workers.dev/chain/fee-history — $0.004 — Base base-fee history over the last 10 blocks with gas-used ratios.
- GET https://x402-data-api.sigrunner.workers.dev/defi/chains-tvl — $0.004 — Top chains by DeFi TVL.
- GET https://x402-data-api.sigrunner.workers.dev/crypto/stablecoins — $0.004 — Top stablecoins by supply + peg price.
- GET https://x402-data-api.sigrunner.workers.dev/defi/protocols-top — $0.004 — Top DeFi protocols by TVL.
- GET https://x402-data-api.sigrunner.workers.dev/defi/dex-volume — $0.004 — Top DEXs by 24h volume.
- GET https://x402-data-api.sigrunner.workers.dev/crypto/fear-greed — $0.002 — Crypto Fear & Greed Index (alternative.me).
- GET https://x402-data-api.sigrunner.workers.dev/crypto/trending — $0.004 — Trending coins on CoinGecko right now.
- GET https://x402-data-api.sigrunner.workers.dev/defi/fees-top — $0.003 — Top DeFi protocols by 24h fees (DefiLlama).
- GET https://x402-data-api.sigrunner.workers.dev/crypto/global — $0.004 — Global crypto market cap, volume, BTC/ETH dominance.
- GET https://x402-data-api.sigrunner.workers.dev/crypto/markets-top — $0.004 — Top coins by market cap with price and 24h change.
- GET https://x402-data-api.sigrunner.workers.dev/crypto/movers — $0.004 — Top 24h gainers and losers.
- GET https://x402-data-api.sigrunner.workers.dev/brief/market — $0.01 — One-call market brief: sentiment, global stats, movers, trending, DeFi fees.
- GET https://x402-data-api.sigrunner.workers.dev/crypto/exchanges-top — $0.004 — Top exchanges by trust score and volume.
- GET https://x402-data-api.sigrunner.workers.dev/crypto/categories — $0.004 — Crypto sector market cap and 24h change.
- GET https://x402-data-api.sigrunner.workers.dev/defi/hacks-recent — $0.004 — Most recent DeFi hacks and exploits with amounts.
- GET https://x402-data-api.sigrunner.workers.dev/crypto/derivatives-exchanges — $0.004 — Top derivatives exchanges by open interest and volume.
- GET https://x402-data-api.sigrunner.workers.dev/defi/protocol-risk?protocol=aave-v3 — $0.01 — Protocol risk score joining TVL, age, audits and hack history.
- GET https://x402-data-api.sigrunner.workers.dev/defi/safe-yields — $0.01 — Vetted stablecoin yields joined with protocol age and hack history.
- GET https://x402-data-api.sigrunner.workers.dev/defi/yields-top — $0.004 — Top DeFi yield pools by TVL with APY.
- GET https://x402-data-api.sigrunner.workers.dev/defi/yield-entry-verdict?pool=<DefiLlama poolId>&token=<0x…> — $0.01 — per-pool go/no-go: SUSTAINABLE|DECAYING|OUTLIER|AVOID + risk score + field-cited reasons from APY trend, stability forecast, IL, volatility, outlier flag and TVL. The should-I-enter-THIS-pool call after /defi/yields.
- GET https://x402-data-api.sigrunner.workers.dev/ai/classify?text=<…>&labels=a,b,c — $0.004 — Zero-shot classification into one of your labels.
- GET https://x402-data-api.sigrunner.workers.dev/ai/summarize?text=<…> — $0.004 — 1-3 sentence summary of a passage.
- GET https://x402-data-api.sigrunner.workers.dev/ai/translate?text=<…>&to=es — $0.004 — Translate text into a target language.
- GET https://x402-data-api.sigrunner.workers.dev/ai/extract?text=<…>&fields=a,b,c — $0.005 — Text-to-JSON extraction into exactly the fields you name.
- GET https://x402-data-api.sigrunner.workers.dev/chain/blob-base-fee — $0.004 — Base EIP-4844 blob base fee (wei/gwei) from the GasPriceOracle.
- GET https://x402-data-api.sigrunner.workers.dev/chain/eth-usd — $0.001 — Chainlink ETH/USD spot price on Base with staleness.
- GET https://x402-data-api.sigrunner.workers.dev/chain/btc-usd — $0.001 — Chainlink BTC/USD spot price on Base with staleness.
- GET https://x402-data-api.sigrunner.workers.dev/chain/prices — $0.001 — BTC/ETH/LINK/SOL Chainlink USD prices in one call.
- GET https://x402-data-api.sigrunner.workers.dev/chain/sol-usd — $0.001 — Chainlink SOL/USD spot price on Base with staleness.
- GET https://x402-data-api.sigrunner.workers.dev/chain/link-usd — $0.001 — Chainlink LINK/USD spot price on Base with staleness.
- GET https://x402-data-api.sigrunner.workers.dev/chain/total-supply?token=<0x…> — $0.002 — ERC-20 total supply (raw + formatted).
- GET https://x402-data-api.sigrunner.workers.dev/chain/allowance?token=<0x…>&owner=<0x…>&spender=<0x…> — $0.002 — ERC-20 allowance, flags unlimited approvals.
- GET https://x402-data-api.sigrunner.workers.dev/chain/code?address=<0x…> — $0.002 — contract-code check for a Base address (EIP-7702 delegated-EOA aware).
- GET https://x402-data-api.sigrunner.workers.dev/chain/wallet?address=<0x…> — $0.003 — wallet bundle: balance + balance_usd + tx count + contract check (EIP-7702 delegated-EOA aware), one call.
- GET https://x402-data-api.sigrunner.workers.dev/chain/simulate?from=<0x…>&to=<0x…>&data=<0x…>&value=<wei> — $0.005 — prospective-tx dry-run: will_revert + revert_reason + gas_used + token asset_changes BEFORE you send it. Keyless, Base-native, Tenderly/Alchemy-class output with no API key. The pre-trade check for any swap/approve/transfer.
- WHY /gate/swap vs raw honeypot-flag APIs: raw flags make your agent interpret; this returns ONE decision (GO|HOLD|BLOCK) sized to YOUR trade (notional_usd vs Uniswap v3 liquidity price impact) plus a reason. Try free: https://x402-data-api.sigrunner.workers.dev/gate/swap/preview?token=degen
- GET https://x402-data-api.sigrunner.workers.dev/gate/swap?token=<0x…>&side=buy&notional_usd=500 — $0.008 — pre-trade GO/HOLD/BLOCK gate for Base trading agents: honeypot/sellability + liquidity-vs-trade-size price impact in one fast call.
- GET https://x402-data-api.sigrunner.workers.dev/chain/token-report?token=<0x…> — $0.01 — DECISION-GRADE token trade-safety verdict: one call returns SAFE|CAUTION|AVOID + risk_score 0-100 + reasons, bundling honeypot/sellability simulation, owner-renounced/mint/pause/blacklist/fee-setter/upgradeable checks, symbol/name/decimals and Uniswap v3 WETH-pool liquidity USD. Replaces many RPC calls and prevents a bad trade.
- GET https://x402-data-api.sigrunner.workers.dev/chain/token-security?token=<0x…> — $0.009 — token security / honeypot detector: EIP-1967/1822 proxy + upgradeability detection, bytecode scan for mint/pause/blacklist/fee-setter/ownership selectors, owner() renouncement check, live eth_call state-override transfer simulation — risk_score + verdict (clear/review/block) + flags. Real compute, not a thin data wrapper.

## Free (previews — taste the data before you pay)
- GET https://x402-data-api.sigrunner.workers.dev/crypto/prices/preview — free 1-token sample of /crypto/prices.
- GET https://x402-data-api.sigrunner.workers.dev/crypto/funding/preview — free top-1 sample of /crypto/funding.
- GET https://x402-data-api.sigrunner.workers.dev/defi/yields/preview — free top-1 sample of /defi/yields.
- GET https://x402-data-api.sigrunner.workers.dev/defi/safe-yields/preview — free top-3 sample of the paid /defi/safe-yields.
- GET https://x402-data-api.sigrunner.workers.dev/defi/yield-entry-verdict/preview — free sample verdict (current top-TVL pool) of the paid /defi/yield-entry-verdict.
- GET https://x402-data-api.sigrunner.workers.dev/defi/protocol-risk/preview — free sample (aave-v3) of the paid /defi/protocol-risk risk score.
- GET https://x402-data-api.sigrunner.workers.dev/pm/markets/preview — free top-1 sample of /pm/markets.
- GET https://x402-data-api.sigrunner.workers.dev/chain/block-number/preview — free, full live data (identical to the paid route).
- GET https://x402-data-api.sigrunner.workers.dev/chain/gas-price/preview — free, full live data (identical to the paid route).
- GET https://x402-data-api.sigrunner.workers.dev/chain/simulate/preview — free sample dry-run (benign 0-value call) of the paid /chain/simulate.
- GET https://x402-data-api.sigrunner.workers.dev/gate/swap/preview?token=usdc|weth|cbbtc|aero|degen — free live sample of the go/hold/block gate (default Base USDC, buy, $100). ALSO: pass any real Base 0x token address for 3 free checks/day/IP.
- GET https://x402-data-api.sigrunner.workers.dev/chain/token-report/preview?token=usdc|weth|cbbtc|aero|degen — free, full real trade-safety report, same depth as the paid route.
- GET https://x402-data-api.sigrunner.workers.dev/chain/token-security/preview — free, full real analysis of a fixed well-known token (Base WETH), same depth as the paid route.
- GET https://x402-data-api.sigrunner.workers.dev/scan/mcp/preview?url=<mcp-server> — free preview (counts + risk score; withholds detail).
- GET https://x402-data-api.sigrunner.workers.dev/enrich/tech-risk/preview?domain=<d> — free preview (verdict + CVE/KEV counts + top CVE; withholds full list).
- GET https://x402-data-api.sigrunner.workers.dev/.well-known/x402 — machine-readable discovery manifest.

## Resellers / referral partners
Featuring these endpoints in your MCP client, router, or agent? Append &ref=<your-tag> to any call URL (e.g. https://x402-data-api.sigrunner.workers.dev/gate/swap?token=aero&ref=yourname). The tag rides through the x402 402→sign→retry and is recorded on the settled on-chain call, so your referred volume is measurable and attributable — we can reconcile exactly how many settled calls (and distinct buyers) your integration drove, with Base txHashes. Ask contact@greyridgesignals.ai for a reconcile report on your tag.

## Referenced by (third-party integrations)
- x402-pilot (DrVelvetFog) — an x402 verification/review toolkit for agents. Its reference live Base-mainnet (EVM) "exact" verify target points at this endpoint, so the project's verify flow exercises a real x402 v2 seller end to end. See examples/live-evm-verify-target.md in https://github.com/DrVelvetFog/x402-pilot (merged). The safety verdicts are Grey Ridge Signals' own analysis; x402-pilot references the endpoint as a live target and does not vouch for the verdicts.

## Where to buy (marketplaces / MCP buyer-adapters)
These third-party x402 buyer tools let agents discover and purchase pay-per-call APIs (including ours) with Base USDC — useful if you want a ready-made buyer client instead of wiring x402-fetch yourself:
- DopamineDesk x402 Marketplace (by Blaz Algo Systems) — plain-language product discovery, free previews, and capped Base-USDC purchases through one MCP adapter. Repo: https://github.com/jblaz6335/mcp-server-aidatamarketplace — integration partner; our token-safety gate (/gate/swap) and token report (/chain/token-report) pair with their token-audit and transaction-preflight tools.