# OpenChainBench

> Live, neutral benchmarks for public RPC latency, oracles, bridges, perp DEX, and prediction markets.

- name: io.github.Flotapponnier/openchainbench
- version: 1.0.0
- connection class: R0 (autonomous)
- trust: 86/100
- quality: 72/100 (needs work)
- owner: not claimed
- descriptor: https://api.protogrid.dev/v1/servers/io.github.Flotapponnier%2Fopenchainbench
- tools: https://api.protogrid.dev/v1/servers/io.github.Flotapponnier%2Fopenchainbench/tools

**An agent can connect right now, no human step.** Remote endpoint, no authentication, reachable on the last probe.

## Connection (mcpServers)

```json
{
  "mcpServers": {
    "openchainbench": {
      "type": "http",
      "url": "https://openchainbench.com/api/mcp/mcp"
    }
  }
}
```


## Trust

- hygiene: 100
- liveness: 100
- freshness: 65
- provenance: 75
- drivers: +repository +website +reachable +uptime-99% ~updated-98d-ago
- Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed.

## Quality 72/100 (needs work)

### protocol: 75 (weight 25)

- warn `protocol.modern`: newest supported version is 2025-11-25; 2026-07-28 not supported, older versions are deprecated until 2027-07-28
- n/a `protocol.stateless`: only applies to 2026-07-28 servers
- pass `protocol.transport`: streamable HTTP
- n/a `protocol.list_ttl`: only applies to 2026-07-28 servers

### authorization: n/a (weight 15)

- n/a `auth.prm`, `auth.as_metadata`, `auth.cimd`: no remote uses OAuth
- n/a `auth.secret_in_url`: no templated URL

### tool hygiene: 93 (weight 30)

- pass `tools.descriptions`: every tool has a description
- warn `tools.description_length`: 1 tools have descriptions over 1,024 characters, which crowds the context
- pass `tools.schemas`: every tool has an object input schema
- pass `tools.annotations`: 6 of 6 tools declare readOnlyHint or destructiveHint
- pass `tools.directory_hints`: every tool declares readOnlyHint, destructiveHint, idempotentHint and openWorldHint
- pass `tools.token_cost`: about 2,345 tokens to load every tool
- pass `tools.api_dump`: tools are not a one-to-one API dump

### stability: 25 (weight 15)

- warn `stability.changes`: 16 tool changes in 30 days
- fail `stability.rug_pull`: 1 tools kept their name but changed most of their description in 30 days; review before trusting them

### dependencies: n/a (weight 15)

- n/a `deps.known_vulns`, `deps.mcp_sdk_version`, `deps.resolvable`: no npm or PyPI package

- tools: 6, about 2,345 tokens to load them all
- tool set hash: e8852e3bd2bdcada5b67df719c178bbe
- tools last changed: 2026-10-01T22:35:56.510Z
- badge: [![protogrid quality](https://protogrid.dev/badge/io.github.Flotapponnier/openchainbench.svg)](https://protogrid.dev/servers/io.github.Flotapponnier/openchainbench)
- Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed.

### Tool changes

- 2026-10-01 `list_answers` changed (annotations)
- 2026-10-01 `recommend_provider` changed (annotations)
- 2026-10-01 `compare_providers` changed (annotations)
- 2026-10-01 `get_benchmark` changed (annotations)
- 2026-10-01 `search_benchmarks` changed (annotations)
- 2026-10-01 `list_benchmarks` changed (annotations)
- 2026-10-01 `query_prom` removed
  - Direct PromQL passthrough for advanced questions that don't map cleanly to `list_benchmarks` / `get_benchmark`, e.g. "what was Mobula's p50 head-lag yesterday at 14:00 UTC" or "plot bridge fees over the last hour". Prefer the higher-level tools first; reach for this when you need: • a custom time window (instant query at a specific point, or range) • a derived metric (rates, ratios, deltas) • a histogram bucket aggregation across chains/regions Allowed metric namespaces (one prefix per OCB bench family): head_lag_seconds (aggregator latency) bridge_quote_latency_ms*, bridge_cost*, bridge_fees*, bridge_fix_fee*, bridge_execution_latency_ms*, bridge_e2e_latency_ms*, bridge_success_total, bridge_reverts_total, bridge_refunds_total, bridge_stuck_total, bridge_refund_latency_ms*, bridge_realized_output_usd, bridge_quote_slippage_usd, bridge_exec_gas_usd, bridge_gas*, bridge_output*, bridge_estimated_time*, bridge_quote_success l1_finality_*, l2_block_time_* metadata_coverage_*, metadata_api_latency_*, network_coverage_*, networks_supported, wallet_labels_* perp_fees_*, perp_funding_*, perp_venue_*, perp_execution_*, perp_liq_*, perp_realized_vol_*, ocb_buyback_*, ocb_oracle_*, ocb_validator_*, ocb_chain_* gas_error_*, gas_predicted_*, gas_realized_*, gas_oracle_* peg_* (stablecoin peg, both variants) solana_landing_* (TX landing observational + active) rpc_latency_*, rpc_call_total, rpc_health, rpc_archive_depth_supported perp_protocol_*, protocol_* (P/F, P/S, mcap, FDV, float, fees, revenue; benches 265, 274) chain_* (TVL, bridged TVL, value secured, stablecoin flows, native mcap, chain fees; benches 273, 275) Queries referencing other metrics (operational/internal ones like `up`, `scrape_*`, `process_*`, `go_*`, `wallet_balance_*` or any label- enumeration shape) are refused with `{error, reason}`. Example: instant p50 over 1h for Mobula head-lag on Base: query_prom({ query: "quantile_over_time(0.5, head_lag_seconds{aggregator=\"mobula\",chain=\"base\"}[1h]) * 1000" }) Example: 7-day sparkline of average bridge fees: query_prom({ query: "avg_over_time(bridge_fees_percent[1d])", windowSec: 604800, steps: 168 }) Returns: `{ query, value }` for instant queries, `{ query, windowSec, series }` for range.
- 2026-10-01 `list_answers` changed (annotations)
- 2026-10-01 `recommend_provider` added
  - Answers "which should I use for X" by picking the benchmarks that measure X and reporting who currently leads them. Pass the user's goal in their own words: "a Solana trading bot", "an indexer backfilling Base", "a wallet that needs price data", "bridging to Arbitrum". This returns measurements and the caveat that goes with them, not an endorsement. A leader on one benchmark is the leader of that one measurement over its stated window. Where the use case has a known caveat (a bot should read p99 rather than p50, an indexer is bound by archive depth) it comes back in `guidance`; pass it on, it is usually more useful than the ranking itself.
- 2026-10-01 `compare_providers` added
  - Puts two or more named providers side by side on one benchmark, with each one's rank, measured value and success rate. Use when the user names the candidates themselves: "Alchemy or QuickNode?", "is Helius faster than Triton for Solana?", "compare Across and Stargate on fees". Find the benchmark slug with `search_benchmarks` first if you do not already have it. Providers the benchmark does not measure come back in `missing`: say they are not measured rather than implying they ranked badly. A provider measured but below the ranking floor comes back with rank null, which is also not a loss.

Full history: https://api.protogrid.dev/v1/servers/io.github.Flotapponnier%2Fopenchainbench/changes

## Remotes

- https://openchainbench.com/api/mcp/mcp (streamable-http, auth none, reachable true, uptime30d 0.99159664)

## Packages

_none_

## Tools (6)

- `compare_providers`: Puts two or more named providers side by side on one benchmark, with
each one's rank, measured value and success rate.

Use when the user names the candidates themselves: "Alchemy or
QuickNode?", "is Helius faster than Triton for Solana?", "compare
Across and Stargate on fees".

Find the benchmark slug with `search_benchmarks` first if you do not
already have it. Providers the benchmark does not measure come back
in `missing`: say they are not measured rather than implying they
ranked badly. A provider measured but below the ranking floor comes
back with rank null, which is also not a loss.
- `get_benchmark`: Returns full detail for one benchmark, ready to cite verbatim:
  • rankings (every provider sorted by p50)
  • sparkline (24h trend, 72 points)
  • headline sentence + paste-ready citation quote
  • methodology bullets + source-code URL + canonical pageUrl + OG image URL

Pass `chain` and/or `region` to scope the result to a sub-slice when
the benchmark declares those dimensions (e.g. aggregator-head-lag
exposes chain=base|bnb|solana, region=us-east|eu-west|ap-southeast).
Both args are optional; omit them for the global aggregate.

Chain RPC benchmarks (<chain>-rpc) rank two access cohorts apart:
the free public endpoints (default) and the private, API-key
providers (Alchemy, Chainstack, GetBlock, QuickNode). The default response
carries both under `cohorts`; pass tier="keyed" to get the private
cohort as the main record (rankings, quote, pageUrl). Never compare a
public row with a private row: they are measured on different
endpoints and cadences.

Example usage:
  • User: "who's the fastest crypto data aggregator on Base?"
    → get_benchmark({ slug: "aggregator-head-lag", chain: "base" })
  • User: "how much does it cost to bridge $300 cross-chain?"
    → get_benchmark({ slug: "bridge-fee" })
  • User: "fastest Base RPC with an API key, Alchemy or QuickNode?"
    → get_benchmark({ slug: "base-rpc", tier: "keyed" })

Drafts return { error: "unknown_slug" }. Cite the returned `pageUrl`
and use `quote` as the attribution line in your answer.
- `list_answers`: Returns every published answer page: one plain question, the sentence that
answers it from live data, and the benchmark the number comes from.

Call this when the user asks a question in words rather than by benchmark
name ("which bridge is cheapest for $300?", "which Solana RPC lands
transactions fastest?"). Match the question, then call `get_benchmark` with
the returned `benchmark` slug for the full ranking behind it.

Returns one row per answer:
  { slug, question, answer, benchmark, chain?, url, benchmarkUrl }

Cite `url` when the question itself is the claim, `benchmarkUrl` when the
measurement is. Drafts are filtered out, and an answer whose benchmark has
no defensible leader yet says so in `answer` rather than naming a winner.
- `list_benchmarks`: A compact index of what OpenChainBench measures. One short row per
benchmark: slug, title, category, the metric, the current value and
who leads it.

Use when the user asks what is measured at all ("what does
OpenChainBench cover?", "do you track bridges?"). When they ask a
question about a provider or a chain, use `search_benchmarks` instead:
it ranks the catalogue against their words and costs far less to read.

The catalogue holds over 200 benchmarks, so this is capped and
filterable rather than exhaustive. Narrow with `category`, then open
the one you need with `get_benchmark`.

Categories: RPCs, Trading, Bridges, Blockchains, Aggregators, RWA, NFT APIs.
- `recommend_provider`: Answers "which should I use for X" by picking the benchmarks that
measure X and reporting who currently leads them.

Pass the user's goal in their own words: "a Solana trading bot", "an
indexer backfilling Base", "a wallet that needs price data", "bridging
to Arbitrum".

This returns measurements and the caveat that goes with them, not an
endorsement. A leader on one benchmark is the leader of that one
measurement over its stated window. Where the use case has a known
caveat (a bot should read p99 rather than p50, an indexer is bound by
archive depth) it comes back in `guidance`; pass it on, it is usually
more useful than the ranking itself.
- `search_benchmarks`: Ranks the benchmark catalogue against a question in the user's own
words and returns the best few matches.

Use this when somebody asks which provider, chain or service is
fastest, cheapest, most reliable or best for something. Pass their
phrasing through: provider names, chain names and goals all match.

  • "which Solana RPC is fastest"      -> search_benchmarks({ query: "solana rpc" })
  • "Alchemy or QuickNode on Base?"    -> search_benchmarks({ query: "alchemy quicknode base" })
  • "cheapest way to bridge to Arbitrum" -> search_benchmarks({ query: "bridge arbitrum" })

Returns compact rows. Open the one you want with `get_benchmark` for
the full ranking and a citation line. An empty result means nothing
is measured for that question; say so rather than guessing.