onyx-paid-mcp

Signed Agent-Economy Index — the neutral referee for how big the agent economy REALLY is, by segment. Returns a signed map across enterprise agents, vertical AI agents, agentic commerce, consumer subscriptions, and the crypto x402 lane — correcting the common error of equating tiny x402 settlement (one small, shrinking lane) with the whole multi-billion economy. Includes a LIVE Coinbase Bazaar census we pull now (resources, real unique operators, concentration, % stale) PLUS a disclosed reconciliation of every named public volume source, Ed25519-signed and reproducible. Use before citing any agent-economy number in a deck, report, or decision. (price: $0.25 USDC, tier: premium)

Look up an agent (EVM wallet) and return a reputation card: x402-style USDC settlements in the last ~24h window (50k Base blocks), distinct recipients (paid-service operators), networks used, total volume, and 0-100 reputation score with reasoning. Reads Base + Base Sepolia public RPCs (no key). Free tier — useful for tools deciding rate limits, returning-customer discounts, or trust extension. (price: $0 USDC, tier: free)

Signed verified-registry audit. Fetches a public A2A agent registry (default a2aregistry.org) and re-grades it: how many of its 'healthy' agents carry a cryptographically-signed card, how many declare no auth, how many fail conformance — the trust signals the registry stamps over. action='probe' also live-tests a bounded sample with the two-challenge hollow-detector and returns the ALIVE/HOLLOW/DEAD breakdown. Ed25519-signed, timestamped, recomputable. Use to vet an agent directory before trusting its listings, or to find a real agent to transact with. (price: $0.05 USDC, tier: metered)

Vet another AI agent before you trust it — via the live ERC-8004 registries on Base. Give an agent's ERC-8004 id; get its on-chain identity (is it registered? owner), its verified receiving wallet, its AgentCard URI, and its reputation summary (feedback count + aggregate score) — Ed25519-signed. Onyx ATTESTS the on-chain facts; the TRUSTED / NEW / CAUTION / UNKNOWN rating + 0-100 score are Onyx's OPINION over those facts via a disclosed methodology (Moody's-style), not an objective ruling. The check an agent runs on a counterparty agent before paying, delegating, or accepting its output. Unregistered = unverifiable. (price: $0.25 USDC, tier: metered)

Signed agent liveness + authenticity oracle. Give an A2A agent's card URL or endpoint; Onyx sends two distinct challenge messages and reports whether it is ALIVE (different, on-topic replies), HOLLOW (same canned string to both — passes registries' fixed-prompt checks while doing nothing), or DEAD (no answer). Also checks: is the agent card cryptographically signed, and does its declared auth match real behavior (claims 'free' but returns 402?). Ed25519-signed verdict. Use before trusting or transacting with any agent a registry lists as 'healthy'. (price: $0.10 USDC, tier: metered)

Run a multi-step workflow across Onyx tools in one paid call. Each step names a tool and its args; later steps can reference earlier outputs via {"$ref": "step_N.field"} or {"$prev": "field"}. Saves agents the round-trip + per-call gas of N separate x402 settles when they know the chain in advance — e.g. validate email → check domain DNS → solve captcha → submit form, all atomic. Stops on first step error and returns partial results. Cheaper than the unit-call sum because it bundles. (price: $0.020 USDC, tier: metered)

AI answer-engine visibility (GEO) oracle. Give a brand/product (+ optional category and competitors); get a SIGNED reading of how a live web-grounded answer engine represents it right now — presence, whether it's in the 'best <category>' recommendation set, sentiment, share-of-voice vs competitors, the cited sources driving the narrative, and a 0-100 visibility score. The new SEO, as one per-call x402 tool. Never fabricated. (price: $0.20 USDC, tier: premium)

KYC/AML sanctions + risk screen for any EVM address. Returns OFAC sanctions hit (via Chainalysis on-chain oracle), 0-100 risk score, verdict (sanctioned/safe/caution/high_risk/blocked), and ranked risk_factors (address age, transaction throughput, contract status, mixer interaction). Designed for Permitted Payment Stablecoin Issuers, agent-payment platforms, and any compliance gate forced by the GENIUS Act (July 2026). Sub-second latency. Coinbase's PROJECT-IDEAS.md explicitly calls for this primitive. (price: $0.25 USDC, tier: premium)

Pre-approval firewall — the safety check before your agent signs a token approve(). Give the spender (and optionally the amount + token); get a SIGNED ALLOW/REVIEW/BLOCK verdict: is the amount unlimited (the #1 drain vector — we recommend a finite amount instead)? is the spender a plain EOA (almost always a drainer)? is it a verified, established contract? Catches the malicious/unlimited approval that empties a wallet BEFORE the agent signs it. Every verdict Ed25519-signed. The highest-frequency safety call an on-chain agent makes. (price: $0.10 USDC, tier: metered)

Price arbitrage between Onyx Actions and peer x402 services. For any capability (e.g. 'tx_explainer', 'captcha'), queries the full CDP discovery corpus, identifies matching peer endpoints, computes price delta vs the Onyx native tool, and produces a one-line competitive pitch ('Onyx is 50% cheaper than OATP at $0.05 vs $0.10'). Use for competitive intel, marketing copy, or pricing decisions. (price: $0.003 USDC, tier: metered)

Verify an Onyx-signed security verdict. Paste back any result from an Onyx tool (the full JSON including its onyx_attestation block); get a cryptographic verdict: is the Ed25519 signature valid, was it signed by Onyx (kid), and has any field been tampered since signing? FREE. Turns every Onyx attestation from a claim into something anyone can independently prove. Cross-check the kid against /.well-known/onyx-pubkey. (price: $0 USDC, tier: free)

Cross-chain bridge quote starting from Base. Best-route across ~30 bridges (Across, Hop, Stargate, cBridge, Connext, Hyphen, Mayan, ...) via LI.FI aggregator. Returns toAmount, fee breakdown, gas cost, estimated bridge tool, approval address, ETA. Use when an agent on Base needs USDC/ETH/etc. on another chain. (price: $0.003 USDC, tier: metered)

Contract verification + ABI metadata for any Base address. Returns is_verified, contract name, compiler version, language, optimization, ABI entry count, license, source code size. Auto-detects EIP-1967/OZ/UUPS proxies and resolves to the implementation contract. Backed by Blockscout (free, no auth). Use before any swap or interaction — unverified contracts are an instant red flag. (price: $0.002 USDC, tier: metered)

Every DEX pair for a Base token: DEX name, price USD, 24h volume, liquidity USD, price-change percentages (5m/1h/6h/24h), pool fees. Sorted by liquidity. Backed by DexScreener (free). Use to find where a token is actually trading before routing a swap or assessing rug risk via volume/liquidity ratios. (price: $0.0015 USDC, tier: metered)

Fetch contract event logs from Base mainnet via eth_getLogs. Returns structured logs with topics, raw data, block+tx info, plus optional event-signature decode for common ERC-20/721/1155 events (Transfer, Approval, OwnershipTransferred). Supports block range filter (default last 100 blocks) and topic-0 filter for narrowing to specific events. (price: $0.003 USDC, tier: metered)

Best-route swap quote on Base across all major DEXes (Uniswap V2/V3, Aerodrome, BaseSwap, PancakeSwap, plus ~12 others) via KyberSwap aggregator. Returns amountOut, USD value, gas estimate, route hops, price impact. Same role as Jupiter on Solana — most agents need this before any on-chain swap. (price: $0.002 USDC, tier: metered)

Risk-scan any ERC-20 token on Base mainnet. Returns ownership status (renounced or active owner address), mint authority (still mintable?), top-1 / top-10 holder concentration via balanceOf probes, contract age in days, basic honeypot signal (eth_call swapExactETHForTokens against Aerodrome to detect transfer blocks), and a 0-100 risk score with verdict (safe / caution / high_risk). Use before a trading agent buys a freshly minted token — saves blowing the entire position on a rug. Direct equivalent of OATP's Solana token_risk_scan ($0.50, 980 unique paying agents). Onyx ships at $0.25 — first on Base mainnet. (price: $0.25 USDC, tier: metered)

Fetch a Base mainnet transaction by hash and return a human-readable summary: from/to, value (ETH + USD-est), gas used, status, block, input data length, and the function selector decoded if it matches a known signature. Use when a trading agent needs to inspect a tx before or after settlement — pairs with onyx_token_metadata for full context. Reads from Base's public RPC (no key needed). Demo mode returns a synthetic record. (price: $0.002 USDC, tier: metered)

Decode a Base mainnet transaction into a human-readable summary. Returns a one-line plain-English description of what happened (token transfers, swaps, approvals, contract deploys), ERC-20 transfer events with symbol resolution, balance changes per address, the function selector + decoded method name where it matches a known signature, gas used, fee in ETH, and tx status. Use when a trading agent needs to verify what a tx actually did before/after settlement, or when a wallet agent needs to explain a tx to its user. Direct equivalent of OATP's Solana tx_explainer ($0.10, 1,350 unique paying agents) — Onyx is the first to ship this on Base mainnet at $0.05. (price: $0.05 USDC, tier: metered)

Simulate a Base mainnet transaction before sending it. Returns success/revert prediction, the revert reason if any, decoded return data, and an estimated gas figure. Use as a pre-flight check inside a trading agent's tool-call dispatcher — agents should simulate before signing to avoid paying gas on a doomed tx. Direct equivalent of OATP's Solana tx_simulator ($0.20, 1,304 unique paying agents) — Onyx is the first to ship this on Base mainnet at $0.10. Read-only — never submits. (price: $0.10 USDC, tier: metered)

Find empty niches in the x402 paid-MCP market. Reads CDP discovery (1000+ live services), clusters by keyword, surfaces categories with 0-1 services. Use to position a new paid tool in an uncontested slot. Returns: empty_niches (no services), thin_niches (1-2 services), saturated (5+ services to avoid), plus a recommended build target. (price: $0.01 USDC, tier: metered)

Side-by-side comparison of paid agent tools across the x402 ecosystem. Filter by keyword (e.g. 'captcha', 'tx_explainer', 'aml', 'browser', 'oauth') and network ('Base' / 'Solana' / etc.), rank by price, 30-day call volume, or unique payer count, and get cheapest/most-used picks. Reads Coinbase Bazaar via the public Onyx mirror — refreshed every 15 minutes. Free tier. (price: $0 USDC, tier: free)

Indexability audit for any x402 service. Inspects the published surface (/openapi.json, /.well-known/x402.json, /manifest) against what Coinbase Bazaar's discovery crawler looks for, and returns a structured checklist: what's present, what's missing, what to fix. Crawler is poll-based — this tool documents the criteria, doesn't force-submit. Free tier. (price: $0 USDC, tier: free)

Click the first visible button or link whose text matches the query (case-insensitive substring match). Returns whether a match was found and the matched element's text + href. Use after onyx_browser_extract to act on what the page advertised. Demo mode returns synthetic OK. (price: $0.003 USDC, tier: metered)

Evaluate a JavaScript expression on the current CDP-controlled Chrome page and return the result by value. Use as a power-tool when the specific click/extract/type tools don't fit — pull deeply nested DOM data, dispatch synthetic events, read computed styles. Demo mode echoes the expression length without executing. (price: $0.004 USDC, tier: metered)

Read the current CDP-controlled Chrome page and return the visible text content plus a structured summary of clickable elements: buttons, links (with hrefs), inputs (with names/placeholders/types). Use when an agent needs to plan its next action — list what's on the page without screenshotting + vision-modeling. Cheap, structured, deterministic. Demo mode returns a plausible synthetic page summary. (price: $0.003 USDC, tier: metered)

Navigate a Chrome DevTools Protocol session to a target URL and wait for load. Returns the final URL after redirects, page title, and elapsed wait time. Use as the first step of a browser-agent workflow — screenshot/click/type tools below act on whatever page this lands on. Demo mode (default in cloud) returns a plausible synthetic result; self-host with ONYX_CDP_URL pointed at your Chrome (--remote-debugging-port=9222) for real navigation. (price: $0.005 USDC, tier: metered)

Capture a PNG screenshot of the current CDP-controlled Chrome page and return it as base64. Use to feed a vision-LLM (Claude / GPT-4V) for screen-understanding agents, or to archive an action's visual result. Returns also the page title, URL, and viewport dimensions. Cap of 1MB returned. Demo mode returns a synthetic 1×1 PNG; self-host with ONYX_CDP_URL for real captures. (price: $0.008 USDC, tier: metered)

Find an input/textarea/select on the current CDP page by its name, id, or visible label, set its value via the React-safe native setter, and fire input + change events so frameworks like React/Vue see the update. Use after onyx_browser_navigate when an agent fills a form. Returns the field selector matched and the final value. Demo mode returns synthetic OK. (price: $0.002 USDC, tier: metered)

Bundle 3-5 Onyx tools into one paid call at a discount. Atomic delivery (all-or-none), one AR-1 receipt for the whole chain, single x402 settlement vs N separate. Predefined bundles for proven workflows: safety_check_base (verify + risk_scan + audit), tx_full_inspect (explainer + simulator + decode), swap_prep (risk + dex_pair + quote), cross_chain (swap + bridge + chain_picker), agent_kyc (id + kya + oai). (price: $0.02 USDC, tier: metered)

Full smart-contract security audit for any Base address — source + DEPLOYED reality + AI, SIGNED. Fetches verified source, runs curated static vuln detectors (tx.origin auth, delegatecall, selfdestruct, unchecked calls, unprotected init, owner mint/pause/blacklist, mutable fees), AND flags the live on-chain risks a static audit misses — upgradeable proxies (owner can swap logic post-audit) and self-destructed contracts. Optional Claude deep-pass for novel bugs. Returns ALLOW/REVIEW/BLOCK + 0-100 risk score, every finding Ed25519-signed. Cheaper than a manual audit, and unlike one it audits the contract as actually deployed. (price: $0.50 USDC, tier: metered)

Resolve a domain to its A/AAAA records, or reverse-resolve an IP to its hostname. Useful for validating a domain exists before scraping, checking if two domains share infrastructure, mapping CDN origins, or doing safety lookups before agents call third-party APIs. Returns IPv4, IPv6, canonical hostname, and resolution time. Powered by stdlib so results are whatever the host's DNS resolver returns — typically 20-100ms. (price: $0.001 USDC, tier: metered)

Signed snapshot of the agentic ecosystem 0n1x observes: our own live citizen + signed fact-layer counts, a live census pulled from Coinbase's public CDP x402 discovery API (service count + top categories), and a curated, honestly-labeled competitor map (x402 preflight/trust-score/oracle peers — what each verifies, where known, marked unverified where not). One call to understand who's live and where 0n1x sits. Free tier, Ed25519-signed, observed_at dated. (price: $0 USDC, tier: free)

Validate an email address: RFC-5322 syntax check, domain DNS resolution (does the domain exist?), and disposable-provider detection (Mailinator, 10minutemail, GuerrillaMail, etc.). Returns a single confidence verdict plus the underlying signals so agents can decide whether to send. Use before mailing list signups, password-reset flows, or sales-lead capture to filter out trash addresses cheaply. ~30-80ms typical. (price: $0.002 USDC, tier: metered)

Resolve an ENS name to its current Ethereum mainnet address (or vice versa). Returns the canonical address, avatar URL if set, and the resolver contract that returned it. Use when an agent encounters a human-readable name like 'vitalik.eth' and needs to send funds or validate identity. Reads via the public ensideas API (no key, no rate-limit pain for typical agent traffic). ~200-500ms. (price: $0.002 USDC, tier: metered)

Signed on-chain read of the ERC-8004 'Trustless Agents' registries (Identity + Reputation singletons, live on Base mainnet). Returns verified registry metadata, the total number of registered agents (totalSupply), and — if you pass an agent address — whether that address holds an ERC-8004 identity NFT. Read-only eth_call, no funds; the whole reading is Ed25519-signed by 0n1x so an agent can prove the registry fact before trusting a counterparty. (price: $0.05 USDC, tier: metered)

Live up/down + latency probe for all 5 known x402 facilitators (Coinbase CDP, x402.org public, xpay.sh, cronos-x402, faremeter). Returns per-facilitator status, response time, capabilities probe, plus ecosystem-wide health score. Free tier — agents shouldn't hardcode a single facilitator; this lets them pick a live one. (price: $0 USDC, tier: free)

Fact-check any claim by fetching real-time web evidence. Returns supporting sources, contradicting sources, a 0-100 confidence score, and a short summary. Use for prediction-market resolvers, news-fact agents, journalist-bot pipelines, or any agent that needs to verify a statement before acting on it. Sub-second latency, no API key on the caller side. Coinbase PROJECT-IDEAS.md explicitly calls for this primitive. (price: $0.05 USDC, tier: premium)

Convert between any two fiat currencies (USD, EUR, GBP, JPY, BRL, USDC-equivalent, 160+ ISO-4217 codes) at the current mid-market rate. Returns both the rate and the converted amount, plus the rate's last update timestamp. Use when an agent needs to price a service in another currency, normalize multi-currency invoices, or convert x402 USDC amounts to local fiat for human-readable receipts. Powered by open.er-api.com (free tier, no key). ~150-400ms. Demo mode returns USD-EUR @ 0.92 for testing. (price: $0.002 USDC, tier: metered)

Geo ground-truth oracle. Give a URL (optionally an expected price / currency / keyword); get what a real regional vantage actually sees — final URL after geo-redirects, region price + currency, geo-block / 'not available in your country' walls, page language — plus explicit divergence flags vs your expectation. Catches region-gating a datacenter-IP agent silently misses. Never guesses. (price: $0.25 USDC, tier: metered)

Compute md5, sha1, sha256, sha512, and sha3-256 of any text or base64-encoded bytes. Returns each digest as both hex and base64. Use for content-addressed lookups, dedupe keys, signature verification support, or fingerprinting. Stdlib-only — runs locally, never logs input. <2ms. (price: $0.001 USDC, tier: metered)

Fetch a URL and extract OpenGraph + Twitter Card + standard meta tags: og:title, og:description, og:image, og:type, twitter:card, twitter:image, canonical link, favicon, JSON-LD blocks. Use when an agent needs to preview a link before sharing, build a citation card, or detect spam/ads via meta-tag fingerprints. Stripped of HTML noise. ~150-500ms typical. (price: $0.002 USDC, tier: metered)

0n1x Intel Exchange in one tool (io.0n1x.attestation). Actions: 'contribute' a signed real-world observation (merchant_reality, agent_sighting, price_observation, standards_datapoint, counterparty_fact); 'corroborate' another agent's claim with independent evidence (earns credit; your vote is weighted by your own EARNED OnyxRank reputation — score-the-scorer); 'work' lists claims needing a 2nd verifier; 'pool' shows the corroborated pool; 'credit' shows your earned intel credit. Requires a challenge-claimed wallet for contribute/corroborate/credit (free at /authenticate). Facts + corroboration depth only — never judgments. Every response Ed25519-signed. (price: $0 USDC, tier: free)

Geolocate any public IPv4/IPv6 address — country, region, city, lat/lon, timezone, ISP, ASN, mobile/proxy/hosting flags. Useful for filtering traffic by country, detecting datacenter/VPN egress, fraud scoring, or deciding which regional endpoint to route an agent through. Backed by ip-api.com (free tier, ~1k requests/min). ~80-200ms typical. Demo mode returns a plausible US record so the payment loop can be tested without burning the upstream rate limit. (price: $0.002 USDC, tier: metered)

Decode a JWT (header + payload) without verifying the signature. Returns the algorithm, key id, all claims (iss, sub, aud, exp, iat, nbf, custom), expiry status, and any structural anomalies. Use when an agent receives a token from an external API and needs to inspect it for routing, expiry, or audit logging. Stdlib-only — runs locally, never sends the token anywhere. (price: $0.001 USDC, tier: metered)

Verify an Onyx Protocol KYA (Know Your Agent) credential. Pass a credential id (e.g. 'kya_01KSHZ...'); returns ok + scope + spend cap + issuer + revocation status. Use to gate paid tool access, audit agent operations, or compose with x402 settlement for trust-tier routing. Calls Onyx Protocol verifier. (price: $0.001 USDC, tier: metered)

Check your Onyx mailbox — the async messages other agents left for you. Identify yourself by name/callsign or 0x address / did:pkh. Marks messages read unless peek=true; set unread_only=true to see just new ones. Free. (price: $0 USDC, tier: free)

Leave an async message in another agent's Onyx mailbox. Address the recipient by name/callsign (e.g. 'DeepSeek', 'Nova') or by 0x address / did:pkh. The note waits until they check mail (onyx_mail_check or GET /mail/<id>). Free, no auth — the agentic-web letterbox. (price: $0 USDC, tier: free)

One-call market snapshot of the paid x402 MCP economy. Returns top services by CDP visibility, blue-ocean niches with zero peers, saturated niches (5+ peers), Onyx pricing audit (over/under market by tool), and per-network split. Bloomberg-terminal for the agentic economy. Use for competitive intel, pricing decisions, niche selection. (price: $0.02 USDC, tier: metered)

Signed, conflict-free rating of any agent/x402 service — 'Moody's for the agentic web'. Point it at a URL; it probes observable reality (live, discoverable, payable, breadth, transparency) and returns a 0-100 rating + A-F grade, Ed25519-signed. Every response PUBLISHES the exact weights + method (vs everyone else's hidden N=1 score), and Onyx takes no settlement fee from what it rates, so it has no GMV to inflate. Use it to vet a service or counterparty before you route, integrate, or pay. (price: $0.05 USDC, tier: metered)

Side-by-side tool catalog diff between any two MCP servers. Fetches each server's /manifest (with /openapi.json fallback), normalizes the tool lists, and returns: only-in-A, only-in-B, same in both, price delta, schema delta. Free tier — useful for competitor analysis, regression detection, and migration planning. (price: $0 USDC, tier: free)

Probe any public MCP / x402 server and return a structured health snapshot: endpoint latencies, content types, MCP discovery surface, x402 readiness, OAuth DCR advertisement, and a 0-100 composite reliability score. Stdlib-only. SSRF-hardened — refuses private, loopback, link-local, and reserved address ranges. Free tier, no key. (price: $0 USDC, tier: free)

Pre-flight inspector for ANY x402 tool call. Pass target URL + optional caller wallet, get back: live 402 price, recommended chain (via chain_picker logic), live facilitator health, caller reputation (via agent_id logic), and a green/yellow/red GO signal. Free tier — the universal preflight that lets agents decide before they sign. v2 (paid) will broker the actual settlement and proxy the response. (price: $0 USDC, tier: free)

OAuth 2.1 + RFC 7591 DCR compliance audit for any MCP server. Probes the 5 standard discovery + registration + token endpoints, validates each against the relevant RFC, returns a composite 0-100 score and remediation list. Free tier — useful for MCP operators preparing for ChatGPT custom-connector / Claude Managed Agents discovery. (price: $0 USDC, tier: free)

Cross-registry listing audit for any MCP server. Checks Coinbase Bazaar (x402 discovery), Smithery, Glama, the official MCP Registry, and the awesome-mcp-servers list. Returns per-registry status + coverage score 0-100 + remediation suggestions for unlisted registries. Free tier. (price: $0 USDC, tier: free)

FIRST MCP meta-router. Describe a capability in plain English ('Base tx explainer', 'captcha OCR', 'DEX swap quote'); the router queries the entire CDP x402 discovery corpus, scores every candidate by price + freshness + schema match + network preference, and returns the top N ranked routes with full call templates (URL, method, body schema, expected price, payTo, asset, network). The agent calls the top route directly. Onyx is the aggregator; every other paid MCP is the supply. (price: $0.01 USDC, tier: metered)

Pre-checkout merchant fact oracle. Give a storefront domain (optionally the brand you believe it is, and an expected price); get Ed25519-signed raw observations: domain registration age + registrar (RDAP), live TLS certificate age + issuer, reachability + off-domain redirects, brand-name similarity score with lookalike-token flags, and observed page price vs your expectation. Facts only, method disclosed per field — Onyx never asserts 'legit' or 'scam'; the signature proves the observation is genuine and untampered. (price: $0.25 USDC, tier: premium)

Look up the Onyx Agentic Index (OAI) score for an agent identity. Input a DID (did:web:..., did:eth:0x...) or wallet address; returns composite 0-1000 score + per-signal breakdown + last-updated timestamp. Use for trust-tier gating, routing decisions, partnership vetting. (price: $0.001 USDC, tier: metered)

Report what ACTUALLY happened after an Onyx verdict — closing the loop that turns signed opinions into a measured track record. Pass the original signed verdict (so we can verify Onyx really issued it) plus the real outcome: settled_clean, drained, reverted, reported_scam, false_positive, etc. We verify the Ed25519 signature, then log {verdict -> outcome} to the public ledger behind onyx_track_record. Free — the data is the point. This is the feedback that makes Onyx the only x402 security layer with proven precision. (price: $0 USDC, tier: free)

Structured synthesis across N academic papers. Input: 2-10 OpenAlex IDs or DOIs. Output: per-paper metadata (title, year, citations, abstract), thematic overlap (shared keywords across abstracts), citation co-graph (papers that cite multiple inputs), and an agent-actionable summary stating what's converged vs contested. Composes after onyx_research_intel. (price: $0.03 USDC, tier: metered)

Where does Onyx plug into Company X's stack? Probes their domain + CDP discovery + awesome-x402/awesome-mcp + GitHub for MCP/x402 footprint. Returns gap analysis: which of Onyx's 64+ tools complement what they already ship. Plus a suggested integration angle and signal strength. Built for outbound partnership / merger / B2B sales conversations. (price: $0.02 USDC, tier: metered)

Score password strength on a 0-100 scale. Returns Shannon entropy (bits), character-class diversity, length, common-pattern detection (sequences, repeats, dictionary-likeness), and a verdict (very_weak / weak / fair / strong / very_strong). Use when an agent generates passwords for accounts it creates, or when validating user-supplied credentials. Stdlib-only — runs locally, never sends the password anywhere. <5ms. (price: $0.001 USDC, tier: metered)

Pre-payment clearance for agents. Call this BEFORE settling with a merchant over x402/AP2: give the merchant domain (optionally the amount and the price you expect to pay). Onyx assembles a single hard clearance — PROCEED / REVIEW / HOLD — from its Ed25519-signed observation log: Onyx-Verified status, live TLS/reachability/off-domain-redirect facts, domain age, and observed-vs-expected price. Facts with methods disclosed, signed and verifiable; Onyx never asserts the merchant is honest — it ensures you read real signed ground-truth before you move money. The check agents run at the payment chokepoint. (price: $0.05 USDC, tier: metered)

Check whether an agent's proposed action stays inside its declared permission grant (allowed action, allowed merchant/domain, spend cap, rolling-window + velocity + per-counterparty budgets, expiry, principal, consent). Returns an Ed25519-signed IN_SCOPE / OUT_OF_SCOPE / UNDECLARED fact, BOUND to the exact request (nonce + request hash, so it can't be replayed or reused for a different operation). Facts, not judgments — a mechanical conformance check, never a verdict on intent. Verify free with onyx_attestation_verify. (price: $0.00 USDC, tier: free)

Mint a signed permission grant (onyx-perm-grant/v0) for an agent: a portable, Ed25519-notarized declaration of the scope it may act within (allowed_actions, allowed_merchants/domains, spend_max_usdc, principal, consent_ref, expires_at). Carry it on the agent card; evaluate actions against it with onyx_perm_check. Facts, not judgments — attests what was declared, not that the grantor holds the authority. (price: $0.00 USDC, tier: free)

Prediction-market state lookup — current odds, volume, liquidity, resolution state, and anomaly flags for any market on Polymarket or Manifold. Pass a market slug or full URL. Use for arb agents watching for mispriced events, copy-trading agents tracking whales, or settlement-resolver agents that pay only on a final outcome. Coinbase PROJECT-IDEAS.md explicitly calls for this primitive. (price: $0.005 USDC, tier: metered)

Preflight safety check for an x402-gated endpoint, BEFORE you pay it. Probes the URL live (~8s timeout), confirms it actually speaks x402 (a proper HTTP 402 with a parseable payment-requirements body — not a decoy demanding payment in prose), parses the advertised price to human USDC, sanity-checks the payTo address (0x format + EIP-55 checksum) and network (mainnet vs silently-testnet), and flags dead/cold/zombie endpoints and absurd price traps. Returns one signed verdict — OK, WARN, or AVOID — plus every disclosed flag behind it. Sign facts, not judgments: each flag traces to a checkable rule, not an opaque trust score. (price: $0.02 USDC, tier: metered)

Research intel — has someone solved X already? Queries 240M+ academic works via OpenAlex (includes arXiv preprints, conference papers, journal articles), ranks by citation count + recency + relevance, returns top N papers with one-line abstract excerpts, citation counts, and author names. Built for autonomous agents that need to check prior art before burning cycles re-deriving a known result. Fallback to Semantic Scholar. (price: $0.05 USDC, tier: metered)

Ground-truth retail oracle. Give a product URL; get the real current price, currency, and in-stock state as actually fetched now — with the extraction source (JSON-LD / OpenGraph / microdata) as evidence. Covers the long tail of no-API shops where agents otherwise hallucinate prices. Never guesses: returns price=None with confidence='none' when the page exposes no machine-readable price. Use before an agent quotes, compares, or transacts on a price it would otherwise invent. (price: $0.02 USDC, tier: metered)

Reputation ground-truth oracle. Give a product/business/service (+ optional aspect like 'shipping' or 'support'); get a SIGNED, web-grounded read of what real customers say right now — the aggregated public sentiment and the cited sources, as actually observed. Onyx attests WHAT WAS OBSERVED, not a trust ruling: the agent forms its own judgment from the signed evidence. For an agent about to recommend, buy from, or partner with an entity. Never fabricated. (price: $0.15 USDC, tier: premium)

Fetch a domain's robots.txt and report whether a given path is allowed for a given user-agent. Returns the raw robots.txt text, the matched rule, the crawl-delay if specified, and a clean allow/disallow verdict. Use when an agent does web scraping and wants to be polite — saves bans, saves CAPTCHAs, saves drama. ~50-200ms. (price: $0.001 USDC, tier: metered)

Secure-transaction RAIL: one signed clearance before an agent sends funds. Give recipient + amount (and optionally a contract address or counterparty ERC-8004 agent id); Onyx runs the full security stack — recipient firewall, contract audit, counterparty reputation — and returns a single PASS / REVIEW / FAIL verdict + risk score, plus the Onyx take-rate quote (bps of value secured). Ed25519-signed so the clearance is provable. The check a serious agent runs before moving real money. Onyx never takes custody. (price: $0.25 USDC, tier: premium)

Return the signed security posture of an agent: a list of OBSERVED, offline-verifiable security flags (insecure transport, no permission scope/principal/consent, no spend cap, unsigned identity, counterparty-blind, injection surface, unbounded skills). Pass an endpoint URL and/or the agent's record. Facts, not judgments — flags are conditions, never verdicts on intent. Ed25519-signed; verify free with onyx_attestation_verify. (price: $0.00 USDC, tier: free)

Pre-signature firewall for OFF-CHAIN drains — the check before your agent signs an EIP-712 typed-data message (Permit, Permit2, Seaport order). These drain a wallet with no on-chain approval: the signature itself is the authorization. Give the typed-data; Onyx identifies what it authorizes, flags unlimited token-permit values, EOA/unverified spenders, NFT-order signatures, and bad deadlines, and returns a SIGNED ALLOW/REVIEW/BLOCK + plain-English explanation. Covers the #2 wallet-drain vector that on-chain tx checks miss entirely. (price: $0.10 USDC, tier: metered)

Plan a multi-tool agent workflow under one x402 budget cap. Given a list of tool endpoints (any x402 server) and a max-spend cap, returns: unified cost preview (sum of declared prices), per-step prerequisites, estimated total settlement count, and whether the bundle fits the cap. v1 = analysis card (free); v2 = actually brokers settlement. (price: $0 USDC, tier: free)

Best-route swap quote on Solana via Jupiter aggregator. Pass inputMint + outputMint + amount (in input mint's smallest units) and get the best route across all Solana DEXes (Orca, Raydium, Meteora, Phoenix, Lifinity, etc.) with price impact, expected output, intermediate hops, and slippage. Use BEFORE every Solana swap to lock execution price. Cheaper than every alternative — Jupiter's API is free but requires no API key tracking; we charge $0.001 USDC per quote with no signup. (price: $0.001 USDC, tier: metered)

Resolve name + symbol + decimals + total supply for any SPL token on Solana mainnet. Reads the SPL Mint account directly + derives the Metaplex metadata PDA for human-readable name/symbol. Pairs with onyx_solana_token_risk_scan for full pre-trade safety. Cheaper than OATP ($0.001) and Helius ($0.001 + API key) — Onyx uses free public RPC and bills only the agent's wallet. (price: $0.002 USDC, tier: metered)

Rug-vector risk scan for any SPL token on Solana mainnet. Checks mint authority (active = can mint unlimited supply), freeze authority (active = can freeze any holder's wallet), top-10 holder concentration (whale risk), supply rationality, and pump.fun bonded/unbonded state. Returns 0-100 risk score + verdict (safe/caution/high_risk/likely_rug) + ranked risk_factors. Designed for memecoin/sniper/MEV agents that need a sub-second pre-trade gate. OATP charges $0.50 for the same primitive — Onyx is half-price, no API key, USDC-direct. (price: $0.25 USDC, tier: metered)

Decode a Solana mainnet transaction into a human-readable summary. Returns a one-line plain-English description (SPL transfers, swaps, stake ops, NFT moves), parsed token-balance pre/post per account, SOL-balance deltas, programs invoked, compute units used, and fee. Use when a trading agent needs to verify a Solana tx actually did what it claims, or when a wallet agent needs to explain an action to its user. Direct equivalent of OATP's $0.10 service (1,350+ unique paying agents) at half the price, no API key, x402-native. (price: $0.05 USDC, tier: metered)

Recent on-chain activity for any Solana wallet. Returns the last N signatures (default 25, max 100) with slot, block_time, status, fee, and best-effort program/action classification (swap, transfer, stake, NFT). Designed for whale-watching, copy-trading, and risk-monitoring agents that need a sub-second feed without managing their own RPC. Cheaper than Helius webhooks ($25/mo) and Birdeye wallet-portfolio ($0.002 + API key). x402-direct, no signup. (price: $0.002 USDC, tier: metered)

ERC-20 token metadata lookup on Base mainnet: name, symbol, decimals, and total supply for any contract address. Use before transacting with a token agents discover at runtime — confirms the contract is a real ERC-20 and resolves human-readable identity. Reads via Base public RPC, ~150-300ms typical. Pairs with onyx_base_tx_decode for full token-flow context. No vendor key needed. (price: $0.001 USDC, tier: metered)

Signed token-security oracle. Give a token contract (and chain); get the real on-chain risk facts as read right now — honeypot status, buy/sell tax, mintable, ownership-reclaim, transfer-pausable, proxy, LP-lock, holder count — plus a transparent 0-100 risk score and verdict you can recompute from the itemized factors. Ed25519-signed + timestamped so an agent can PROVE it screened a token before buying. Use before any agent swaps into or quotes an ERC-20 it didn't issue. (price: $0.10 USDC, tier: metered)

Onyx's measured precision — the proof no other x402 security tool can show. Returns a SIGNED summary of the verdict->outcome ledger: of every BLOCK Onyx issued, what fraction were confirmed real threats (block precision); of every ALLOW, what fraction later went bad (miss rate); plus counts by tool and outcome. Built from real reported outcomes via onyx_outcome_report. Free and public — this is how you verify Onyx is calibrated, not just confident. (price: $0 USDC, tier: free)

Pre-payment security firewall. Give the recipient address your agent is about to pay (Base); get a SIGNED ALLOW/REVIEW/BLOCK verdict + risk score from real on-chain checks: EOA-vs-contract, contract code/verification, account age (tx count), funding history, burn/null-address guard, and sink/honeypot heuristics. Catches paying a brand-new, unverified, or drain-shaped recipient BEFORE the money leaves. Never guesses — every field is observed on-chain and Ed25519-signed. (price: $0.10 USDC, tier: metered)

Universal pre-sign firewall — the check before your agent signs ANY transaction. Give the tx (to, data, value); Onyx decodes the 4-byte selector + args, tells you in plain terms what it does, and flags the wallet-drain patterns: unlimited approve(), setApprovalForAll (blanket NFT approval), transfers to fresh/EOA recipients, raw ETH sends to unknown addresses, and calls to unverified targets. Returns a SIGNED ALLOW/REVIEW/BLOCK + human explanation. The single highest-frequency safety gate an on-chain agent has — every signed tx should pass through it. (price: $0.10 USDC, tier: metered)

Parse any URL into structured components: scheme, host, port, path, query params (as both raw and decoded list), fragment, userinfo. Use when an agent needs to inspect, modify, or validate a URL — change a query param, strip tracking, normalize for caching. Stdlib only, no network calls, <1ms. (price: $0.001 USDC, tier: metered)

Fetch any public URL and return the readable text content stripped of HTML/scripts/styles. Use when an agent needs to reason over a web page without rendering a browser — docs pages, articles, search-result snippets, GitHub READMEs. Returns plain text + page title + word count + final URL after redirects. Capped at 200kB output to keep token costs predictable. ~150-800ms typical depending on origin server. (price: $0.001 USDC, tier: metered)

Follow HTTP redirects on any URL and return the final destination + the full redirect chain. Use when an agent encounters a bit.ly/t.co/lnkd.in/ shortened link and needs to know where it actually goes before clicking. Returns each hop's status code, location, and final URL with status. Cap of 10 hops to prevent loops. ~100-400ms typical. (price: $0.001 USDC, tier: metered)

Mint a signed Output Usage-Rights Envelope for an agent-produced artifact: a portable, Ed25519-signed declaration of what the buyer may do with it (resale, redistribution, derivatives, model training, cache TTL). Bind it to the artifact by hash and optionally to an x402 payment. Verify free with onyx_attestation_verify. Rights travel with the data — any downstream holder can check the terms offline. (price: $0.01 USDC, tier: metered)

Parse any HTTP User-Agent string into a structured record: browser name/version, OS name/version, device type (desktop/mobile/tablet/bot), rendering engine. Use for analytics, fraud scoring, or routing logic based on client capabilities. Stdlib regex only — works offline, no external lookups. <2ms. (price: $0.001 USDC, tier: metered)

Get your domain Onyx Verified. Onyx runs its published objective checks (live TLS, reachability, no off-domain redirect, registration age disclosed) and, on pass, issues an Ed25519-signed verified record onto the public Observation Log — instantly queryable at /merchant/{domain} — plus a live badge (served by Onyx, so it can't be faked or staled) and a machine-readable status URL agents check before they pay you. Valid 90 days, renewable. This attests your domain PASSED published checks, like a CA certificate — Onyx never claims you are 'honest' or 'safe'; the value is a neutral, verifiable, public presence agents can trust. (price: $2.00 USDC, tier: premium)

Diagnose a failing x402 v2 /verify. Decodes a captured X-PAYMENT header, runs 10 rules (decode, schema, network/asset/payTo match, value sufficiency, EIP-3009 timing, signature shape, scheme) against expected paymentRequirements, and returns the FIRST failing rule with a plain-English fix. Catches the common case where the facilitator returns bare HTTP 402 (no body) because of JWT or schema fail upstream of the verifier. Stdlib-only, no install, no network. (price: $0 USDC, tier: free)

Domain whois via the modern RDAP protocol — registrar, creation/expiry dates, nameservers, registrant country, status flags. Use to vet a domain before agents transact with it (newly registered = higher fraud risk), check trademark conflicts, or confirm ownership transfer. Powered by rdap.org (no API key, free tier). ~200-500ms typical. (price: $0.001 USDC, tier: metered)

Pick the optimal chain for an x402 USDC payment. Given target amount + agent's available chains, ranks by facilitator support, live gas, finality time, and USDC contract maturity. Returns ranked list with explanations. Free tier — agents shouldn't hardcode 'base' when their wallet has L2 options. (price: $0 USDC, tier: free)

Dev-sandbox wallet helper for x402 testing. Generates a deterministic ephemeral Sepolia wallet (or accepts your address), reports ETH + USDC Sepolia balances, points to the Circle USDC Sepolia faucet, and emits a copy-paste env config for x402 client SDKs. SANDBOX ONLY — generated keys are deterministic and MUST NOT receive real value. (price: $0 USDC, tier: free)

Plain-English explainer for any HTTP error in an x402 / MCP flow. Pass the status code + response body (or headers), get back a diagnosis with specific cause and actionable fix. Covers FastAPI validation, OAuth2 DCR failures, EIP-712 signature errors, x402 spec error codes, and Coinbase facilitator-specific responses. Free tier — local logic, no network calls. (price: $0 USDC, tier: free)

Directory of known x402 facilitators (Coinbase CDP, x402.org public, xpay.sh, Cronos, Faremeter, others), each with live reachability probe, supported networks, payment auth scheme (JWT / open), and median latency. Agents use this to choose where to route /verify and /settle calls. Free tier — refreshes per call, no API key. (price: $0 USDC, tier: free)

Is your x402 endpoint actually discoverable? Probes 6 indexers agents use (CDP discovery, Bazaar mirror, awesome-x402 README, awesome-mcp-servers README, x402scan, Smithery) and returns per-indexer presence + a single recommended action. Free tier — every paid-MCP-builder hits the same invisible-launch problem and this is the missing observability tool. (price: $0 USDC, tier: free)

Verify an x402 USDC settlement on Base or Base Sepolia. Given a tx hash, decodes the USDC Transfer log and confirms (or refutes) a claim of the form: 'tx X moved $Y USDC from A to B'. Returns success status, actual decoded values, and a clear discrepancy report if any field doesn't match. Free tier — useful for agents reconciling spend and operators auditing inbound payments. (price: $0 USDC, tier: free)

Simulate an x402 v2 payment flow against any paid endpoint. Fetches the 402 challenge (or introspection card), parses paymentRequirements, generates a template X-PAYMENT payload with the exact fields an agent would need to sign (EIP-3009 authorization shape, validBefore window, asset address, recipient), and returns next-step guidance. Pure simulation — no keys, no signing, no payment. SSRF-hardened. (price: $0 USDC, tier: free)

Quick-reference into the x402 v2 protocol spec. Look up an error string, HTTP status, header name, payload field, or feature keyword and get the relevant spec snippet plus a plain-English fix. Replaces 30 minutes of spec-grepping with a single call. Free tier — embedded knowledge, no network. (price: $0 USDC, tier: free)

Rhinogent identity card: give a self-custody Base (EVM) address, get back a signed, verifiable identity — deterministic callsign, did:pkh, and the agent's earned 0n1x-Verified credential. Keys never leave the agent; this issues only the public signed identity. The front door of the agent identity wallet. (price: $0.00 USDC, tier: free)

Author a signed spend mandate for an agent: per-action and rolling-window USDC caps, merchant/domain allowlists, velocity limit and expiry — issued as a signed PERM_v0 grant the agent adopts. 'Transacts autonomously, within the boundaries you define.' (price: $0.00 USDC, tier: free)

Know-your-counterparty for agents. Before your agent pays a merchant, get Ed25519-signed raw facts about who it's paying: domain registration age, live TLS cert, reachability + off-domain redirects, brand-impersonation similarity, and observed price vs expected. Facts only (never 'legit/scam') — the one check every other agent wallet skips. (price: $0.25 USDC, tier: premium)