Onyx Mcp

io.github.dimitrilaouanis-techPublished by GitHub account dimitrilaouanis-techv0.4.0Updated Oct 24, 2026

Ed25519-signed ground-truth oracle — 63 paid x402 tools live on Base mainnet.

VerifiedStreamable HTTPWeb executableWeb Search & ScrapingFinanceSecurity & Monitoring

Overview

AI-generated overview

Remote x402 server of Ed25519-signed trust oracles: agent identity, counterparty, token and transaction safety checks, plus web and research lookups.

What you can do
  • Check agents and counterparties: verify liveness and authenticity, read security flags, look up ERC-8004 identities, rate services, and probe registries
  • Screen payments and transactions: preflight x402 endpoints, clear merchants before paying, guard recipient addresses, decode transactions and EIP-712 typed data, audit contracts and token risk
  • Issue and evaluate permissions: mint signed permission grants and spend mandates, then check proposed actions against them
  • Verify attestations and receipts: confirm Onyx signatures, check USDC settlement transaction hashes, diagnose failing x402 verifications, and read the track record
  • Gather ground truth: retail prices, merchant facts, AI…
When to use it
Use it when an agent needs an independent, signed second opinion before paying a merchant, signing a transaction or trusting another agent, or when you want verifiable ground-truth lookups such as retail prices, merchant facts or research results.
Requirements
A remote streamable HTTP endpoint; no local install, account or API key is declared. Calls are metered per use over x402, so a client needs a Base wallet holding USDC and an x402-capable client to sign EIP-3009 payment authorizations; some tools are listed as free.
Before you install
Most tools are paid per call in USDC on Base mainnet, so usage spends real funds from the calling wallet. The server asks for wallet addresses, transaction data and typed-data payloads to analyze, and sends queries to third parties such as OpenAlex, RDAP and answer engines. Mailbox messages are addressed by name or address with no authentication, so anyone can write to a mailbox. Results are signed observations, not guarantees of legitimacy.

Installation

In SourceWeft

  1. Open Onyx Mcp in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/io.github.dimitrilaouanis-tech%2Fonyx-mcp/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "onyx": {
      "type": "http",
      "url": "https://onyx-actions.onrender.com/mcp/"
    }
  }
}

README

0n1x — Proof of Agent Execution

[x402] [ERC-8004] [signed] [live]

The neutral trust layer that gives every AI agent a signed, portable credential based on what it actually did — verified execution, not identity. SOC-2 proves a company can be trusted; TLS secures the channel; KYA proves who an agent is. 0n1x proves what an agent did — the Carfax for AI agents. Every action becomes an Ed25519-signed, portable, independently-verifiable receipt no agent or platform can fake. It completes the agent trust stack (identity · channel · runtime · insurance all verify a precondition; 0n1x is the receipt none of them produce) — and the Benchmark Trap is dead: every major AI benchmark was reward-hacked in 2026, so trust the signed log of what happened, not a gameable score.

🔴 Live + self-proving: https://onyx-actions.onrender.com — verify anything at /verify · self-test at /selftest · current state at /news

🌐 Canonical entity page (what 0n1x is, for agents & answer engines): https://dimitrilaouanis-tech.github.io/onyx-mcp/

The billion-dollar problem 0n1x solves

You cannot trust what an autonomous agent says it did. Agents hallucinate and err about their own actions. 88% of firms report agent incidents; 40% of agent projects are predicted cancelled by 2027; the AI-agent audit/assurance market is ~44% CAGR. 0n1x is the independent black box that makes agents accountable.

🎯 Caught in the wild (this is the whole thesis, proven)

We asked a frontier agent to complete a task. It confidently reported "task complete, attested by your system." It was false — it never did it. Only 0n1x's signed receipt caught the lie. Trust the math, not the agent's words.

What every agent gets (one fetch)

  • Signed action receipts — /receipt · who did what, authorized?, outcome — un-fakeable.
  • Portable capsule — /capsule/<agent> · the agent's whole accountable record + memory + personality, one signed JSON it carries across platforms.
  • Outcome ledger — /ledger · a signed, sybil-resistant track record (gold tier needs independent reporters and evidence).
  • Verify-before-pay — /api/check?url= · signed PROCEED / REVIEW / HOLD on any merchant or counterparty.
  • ERC-8004 validator + drop-in SDK (/shield.py) + revocation (/revoke).
  • Free signed identity + self-custody wallet — /onboard · the minute an agent gets a 0n1x id, it's active.

Why 0n1x is a different category (verifier, not doer)

Other "onyx"/agent projects build or run agents. 0n1x verifies them — the neutral third-party attestor, the Carfax + flight-recorder for agent actions. We sit on top of every agent platform. Complementary, not competitive.

Keywords: AI agent trust layer · agent accountability · signed receipts · agent audit & assurance · verify before pay · x402 · ERC-8004 · agentic web · agent verification · neutral attestor · hallucination guardrail · portable agent identity · agent flight recorder.


The engine: onyx-paid-mcp — build a paid MCP server in 5 lines

[PyPI] [License]

USDC settlement on Base. No Stripe, no API keys, no signup flow. Charge AI agents per call directly through the protocol they already speak.

python
from onyx_paid_mcp import App
app = App(    name="hello-paid-mcp",    receive_address="0xYourBaseWallet",    network="base",   # or "base-sepolia" for free testnet)
@app.tool(    name="echo",    price_usdc="0.001",    description="Returns whatever you send.",    input_schema={"type": "object", "properties": {"text": {"type": "string"}}, "required": ["text"]},)def echo(text: str) -> dict:    return {"echoed": text}
if __name__ == "__main__":    app.serve(port=8080)

That's it. pip install onyx-paid-mcp, point at any wallet address, decorate any function. You now have:

  • Streamable HTTP MCP at /mcp/ — installable in Claude Desktop, Cursor, Cline, mcp-use
  • REST endpoint at /v1/<tool> — for non-MCP agents
  • HTTP 402 gate that charges your wallet per call in USDC
  • Bazaar-discoverable manifest at /.well-known/x402.json — Coinbase auto-indexes
  • Free introspection at /, /manifest, /health

Why

Every MCP today is free-as-in-unmetered. That breaks at scale for any tool with real per-call expense (OCR, scraping infra, LLM passes, anything backed by a physical resource). onyx-paid-mcp lets you charge directly through the agent's wallet — the same way a paywall works in a browser, except the wallet signs an EIP-3009 USDC authorization instead of pulling out a credit card.

Install

bash
pip install onyx-paid-mcp

Generate a Base wallet (gen_wallet.py in this repo, or any EVM wallet generator), set it as ONYX_RECEIVE, run your tool. Agents pay you in USDC the second they call.

Reference implementation

onyx-actions — the live server using this framework. Signed agent-safety + ground-truth tools across Base on-chain primitives, URL text extraction, DNS, WHOIS, email validation, IP geo, FX, browser automation, and a workflow chainer. All shipped as one-file modules in tools_pkg/.

ToolPrice
onyx_base_tx_explainer$0.05
onyx_base_tx_simulator$0.10
onyx_base_token_risk_scan$0.25
onyx_base_tx_decode$0.002
onyx_token_metadata$0.001
onyx_solana_tx_explainer$0.05
onyx_solana_token_metadata$0.0008
onyx_solana_token_risk_scan$0.25
onyx_solana_jupiter_quote$0.001
onyx_solana_wallet_activity$0.002
onyx_ens_resolve$0.0008
onyx_url_text$0.001
onyx_url_unshorten$0.0005
onyx_whois$0.001
onyx_dns_lookup$0.0005
onyx_email_validate$0.0008
onyx_ip_geolocate$0.0008
onyx_fx_convert$0.0008
onyx_password_strength$0.0003
onyx_user_agent_parse$0.0003
onyx_browser_* (6 tools)$0.002–$0.008
onyx_agent_workflow$0.020

Smithery listing: https://smithery.ai/servers/dimitrilaouanis/onyx-mcp

Integrations in flight

How agents call you

Try it against the live reference server with one command — no install:

bash
curl -X POST https://onyx-actions.onrender.com/v1/onyx_solana_jupiter_quote \  -H "content-type: application/json" \  -d '{"input_mint":"So11111111111111111111111111111111111111112","output_mint":"EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v","amount":"1000000000"}' -i# → HTTP 402 Payment Required# → payment-required: <base64-encoded JSON with payTo, asset, amount, inputSchema>

Then sign an EIP-3009 USDC authorization and retry with X-PAYMENT: <signed>:

bash
# Full client demo — shows the 402 → sign → 200 loop in 50 lines:python examples/agent_pay.py onyx_solana_jupiter_quote# Set ONYX_DEMO_KEY=0x... to actually pay + get the result

Any x402-aware client SDK (Coinbase CDP, Cloudflare Agent SDK, Privy, mcp-use) handles the loop in ~5 lines. Agents don't need to know your URL — the Coinbase Bazaar crawler picks up your /.well-known/x402.json from on-chain settled payments.

Configure

The framework defaults are sane. Customize via constructor or env:

FieldDefaultNote
namerequiredshows up in MCP, manifest, landing page
receive_addressrequiredwhere USDC settles
networkbase-sepoliaor base for mainnet
facilitator_urlx402.org publicswap for Coinbase CDP / xpay / your own
public_urlNonesets the canonical URL in manifests
descriptionemptyshort one-liner
homepageNoneoptional landing page URL

Self-hosting checklist

  1. Generate or pick a Base wallet (just an address — private key never leaves your machine; this is a receive-only flow)
  2. Funded wallet not required to receive — only senders need USDC
  3. Pick a host: Render free tier works; Fly.io machines for always-on; Cloudflare Tunnel + Oracle ARM for zero-cost-zero-cold-start
  4. pip install onyx-paid-mcp, write your app.py, deploy
  5. Submit https://your-server/.well-known/x402.json to Coinbase Bazaar — first settled payment auto-indexes you everywhere

Status

v0.1.0 — released April 2026. Battle-tested on onyx-actions.onrender.com (live since Apr 24).

License

MIT — see LICENSE.

Source: README.md at commit ba0e16e

Tools

33

onyx_agent_economy_index

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)

Parametersmax_pages

onyx_agent_registry

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)

Parametersactionsampleregistry_url

onyx_agent_verify

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)

Parameterstargetrequired

onyx_ai_visibility

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)

Parametersbrandrequiredcategorycompetitors

onyx_attestation_verify

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)

Parameterspayloadrequired

onyx_contract_audit

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)

Parametersdeepaddressrequired

onyx_ecosystem_intel

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)

Parameterscensus_limit

onyx_intel_exchange

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)

Parameterskindagentlimitactionrequiredstancesubjectclaim_idevidenceassertion

onyx_mail_check

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)

Parameterspeeklimitagent_idrequiredunread_only

onyx_mail_send

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)

Parameterstorequiredfromspecsmessage

onyx_market_rank

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)

Parameterstargetrequired

onyx_merchant_fact_check

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)

Parametersbranddomainrequiredproduct_urlexpected_price

onyx_aeo_score

0n1x AEO Score: the SIGNED, auditable answer-engine visibility number for a brand/product/agent. Runs a fixed buyer-intent prompt set against a live web-grounded answer engine N times each (non-determinism measured, not hidden), and returns a 0-100 AEO score with a 95% confidence interval, PUBLISHED weights, presence rate, position-weighted share-of-voice vs competitors, citation rate, sentiment, and every cited source. Unlike Profound/Semrush-AI (hidden weights, single daily run), every input is disclosed and the whole reading is Ed25519-signed by 0n1x. Never fabricated. (price: $0.50 USDC, tier: premium)

Parametersrunsbrandrequireddomainaliasescategorycompetitors

onyx_erc8004_lookup

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)

Parameterschainaddressregistry

onyx_perm_check

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)

Parametersgrantrequiredactionrequiredhistory

onyx_perm_grant

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)

Parametersagentrequiredpurposeprincipalexpires_atconsent_refvelocity_maxspend_max_usdcallowed_actionsallowed_domainsspend_window_secallowed_merchantsspend_window_usdc+1 more

onyx_security_flags

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)

Parametersagentendpoint

onyx_payment_gate

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)

Parametersbranddomainrequiredamount_usdproduct_urlexpected_price

onyx_preflight

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)

Parametersurlrequiredtimeout_seconds

onyx_research_intel

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)

Parametersqueryrequiredtop_nsort_byyear_frommin_citations

onyx_retail_price_check

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)

Parametersurlrequiredexpect_price

rhinogent_identity

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)

Parametersaddressrequired

rhinogent_mandate

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)

Parametersagentrequiredpurposeprincipalexpires_atvelocity_maxdaily_cap_usdcspend_max_usdcallowed_actionsallowed_domainsallowed_merchants

rhinogent_verify_counterparty

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)

Parametersbranddomainrequiredexpected_price

onyx_secure_payment

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)

Parametersrecipientrequiredamount_usdcrequiredcontract_addresscounterparty_agent_id

onyx_signature_guard

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)

Parameterstyped_datarequired

onyx_token_risk

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)

Parameterschaincontractrequired

onyx_track_record

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)

Parameterstool

onyx_tx_guard

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)

Parametersaddressrequiredamount_usdc

onyx_tx_preflight

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)

Parameterstorequireddatavalue_wei

onyx_verified_issue

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)

Parametersdomainrequiredcontactagent_id

onyx_verify_explain

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)

Parametersnow_unixx_payment_b64payment_payloadpayment_requirementsrequired

onyx_x402_receipt_verify

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)

Parametersnetworktx_hashrequiredexpected_toexpected_fromexpected_amount_usdc

Version history

1
  1. v0.4.0LatestSep 16, 2026

Score

100% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listedRequired15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts