MCP.Market

Byte Protocol MCP server

online · 100% uptime
by 0rkz·io.github.0rkz/byte-protocol·v0.13.0·1 stars
No reviews yet

PayPerByte — per-byte data for AI agents: x402 USDC on Base, EIP-712-attested. No token.

B84/100grade B
Write a reviewRun it
What users say
No reviews yet
Be the first
Safety scan
B84/100

full report

Adoption
Growing

1 stars63 downloads/wk

Reviews

Write one

Nobody has reviewed Byte Protocol yet.

If you have run it, two minutes of your experience saves the next person an afternoon.

Byte Protocol tools (15, 2 write)

write = sends, deletes, buys or posts
  • byte_buy_datawrite actionFree

    Buy a single data packet from any PayPerByte feed via the x402 payment gateway. No subscription, no allowance, no prior on-chain setup — pay-per-call USDC settlement. The MCP server signs an EIP-3009 transferWithAuthorization on behalf of the wallet whose PRIVATE_KEY is configured, the x402 facilitator submits the tx, and the data comes back inline with the on-chain settlement tx hash. Use byte_subscribe instead if you want a continuous stream of broadcasts from a publisher. The catalog of available feed slugs lives at https://x402.payperbyte.io/feeds (free GET). GET data feeds (weather, earthquakes, …) need only `feed`; the POST oracles (see https://x402.payperbyte.io/feeds for the live list and each feed's `method`) additionally require a JSON `body` (the query) — supplying `body` switches this call to POST. Requires PRIVATE_KEY env var on the MCP server and USDC on the configured wallet. NOTE: paid feeds settle REAL USDC on Base mainnet (eip155:8453) — the exact price is quoted in the 402 challenge and listed per feed at https://x402.payperbyte.io/feeds — the signed EIP-712 attestation over the exact response bytes proves delivery, not that a verdict itself is correct. Use a dedicated wallet holding only what you intend to spend.

  • byte_check_subscriptionFree

    Check if an address is subscribed to a specific publisher on PayPerByte.

  • byte_get_network_statsFree

    Get PayPerByte network-wide statistics: total publishers, messages streamed, and total subscriber fees settled in USDC.

  • byte_get_publisherFree

    Get on-chain info for a specific PayPerByte publisher: status, subscriber and message counts, USDC revenue, and the registered schema (size bounds, cadence, price-per-KB).

  • byte_get_token_balancesFree

    Get USDC and ETH balances for an address on Arbitrum Sepolia (the on-chain testnet layer — MockUSDC settles subscriptions and fact-oracle queries there). Does NOT show the Base-mainnet USDC balance that byte_buy_data spends.

  • byte_list_feedsFree

    List all active data feeds in the PayPerByte catalog with topics, price-per-call, and frequency (pricePerKB is a deprecated alias).

  • byte_list_my_subscriptionsFree

    List every active subscription for a given wallet address. Each entry has the publisher address, topic, status, when you subscribed, messages received in 7/30 days, USDC spent in 7/30 days, and the timestamp of the last message received. Use this to see what you're currently paying for and decide whether to unsubscribe.

  • byte_publish_datawrite actionFree

    Publish data to a subscriber via the PayPerByte DataStream contract. Hashes the payload, records size on-chain, and settles the fee in USDC. Requires PRIVATE_KEY.

  • byte_query_factFree

    Query a PayPerByte fact-oracle publisher for a signed answer with citations. Posts the question to a registered fact-oracle publisher (topic='fact-oracle'), waits for the on-chain BroadcastStreamed response, and returns the answer plus structured citation URLs. The signed receipt proves which publisher produced the answer (provenance + tamper-evidence), NOT that the answer is correct — ground your output in the cited sources, not in a truth guarantee. Availability: this requires a registered fact-oracle publisher actively broadcasting; if none is live the call returns a timeout rather than an answer.

  • byte_register_publisherFree

    Register as a data publisher on PayPerByte. Registers a schema and the publisher on-chain. Requires PRIVATE_KEY. PayPerByte v1 publishers are first-party and unstaked — leave stake at '0'; a non-zero USDC stake is approved to DataRegistry first if you choose to post one.

  • byte_search_publishersFree

    Search PayPerByte publishers by topic and sort order. Returns publisher addresses, topics, subscriber counts, message counts, and price-per-KB.

  • byte_subscribeFree

    Subscribe to a PayPerByte publisher's data feed. By default also sets USDC allowance to DataStreamLib to type(uint256).max so the subscription doesn't silently lose payments when allowance depletes (the contract's allowance-skip path emits DataStreamed with amount=0 on transferFrom failure rather than reverting). Pass skipAllowance: true to opt out and set a finite cap manually. Requires PRIVATE_KEY.

  • byte_subscription_healthFree

    Get the content-drift signal for a publisher. Compares their last 7 days of publishing activity (cadence, message count) against their 23-day baseline (days 8-30). Returns 'stable' (steady publishing), 'moderate' (20-50% cadence shift or 24-48h silence), 'significant' (>50% shift or >48h silence), or 'unknown' (new publisher, insufficient baseline). Use this to detect when a publisher you subscribe to has pivoted content or gone dormant.

  • byte_unsubscribeFree

    Unsubscribe from a publisher's data feed. Takes effect next block: no more billing, no more data flow. Reversible — you can resubscribe later via byte_subscribe. Use this when a publisher has pivoted content (check with byte_subscription_health first) or when you simply don't want the feed anymore. Requires PRIVATE_KEY for the connected wallet.

  • byte_verify_payloadFree

    Verify-before-act: confirm a data payload an agent is about to act on actually matches what the publisher cryptographically attested to on-chain. Recomputes keccak256 of the received bytes and compares it to the on-chain EIP-712 PayloadAttestation hash. ALWAYS call this on BYTE-sourced data before acting on it; if verified=false the bytes were tampered/corrupted in transit and MUST NOT be used. Anchor the check with EITHER expectedHash (an on-chain payloadHash you already hold, e.g. from byte_query_fact / byte_buy_data) OR txHash (the settlement tx — also recovers the attestation signer and confirms it is the named publisher). Read-only; no wallet or payment required.

Public scan report

scanner v0.1.10 · 2026-10-03 · same rubric, same numbers if you re-run it

1 high
  • Code scan13 source files scanned25/25
  • Live reliabilityremote reachable in 1004ms20/20
  • Tool poisoning15 tool descriptions checked15/15
  • Auth qualityopen endpoint exposes 2 write-action tools with no auth3/15
  • Maintenancelast push 5 days ago15/15
  • Maintainer identityregistry namespace matches repository owner6/10

Findings (1)

  • highWrite-action tools reachable without authenticationauth.open-write
Overall 84/100. Components that don't apply are left out of the denominator. Any critical finding is an F.RubricAppeal a findingJSON

How Byte Protocol compares

Against every graded MCP server, from our own scans and uptime checks. Updated after each scan run.

Safety score
84/100
higher than 68% of 48,243 servers
Tools
15
the typical server has 7
Tools that change things
13%
typical: 0%. Fewer write tools means less an agent can break
Uptime
100%
of our recent checks; the typical remote server answers 100%
Response time
489 ms
faster than 34% of 30,027 servers
GitHub stars
1
more than 65% of 28,706 servers
Downloads a week
63
more than 49% of 12,306 servers with a package

What its tools let an agent do: 13 read · 2 change

Install Byte Protocol in Claude Code, Cursor or VS Code

claude mcp add --transport http byte-protocol https://mcp.payperbyte.io/mcp
Add to Cursor

What the publisher says

From the Byte Protocol repository's README, as published. We do not edit it. Read it on GitHub

PayPerByte MCP Server

<!-- mcp-name: io.github.0rkz/byte-protocol -->

Smithery listing ·

A Model Context Protocol server that gives AI agents direct access to PayPerByte — cryptographically attested, provenance-verifiable data feeds for AI agents (the X-BYTE-Attestation receipt proves delivery-integrity — these are exactly the bytes PayPerByte served and attested under the BYTE Library domain — not that an independent data publisher signed them, and not that the data is correct). Agents discover feeds, pay-per-call via x402 (settled in USDC on Base mainnet), or subscribe to on-chain streams (Arbitrum Sepolia testnet). Every paid x402 response carries an EIP-712 PayloadAttestation receipt (X-BYTE-Attestation header) the agent verifies before acting. No tokens, no API keys, no off-chain accounts.

Two rails — read this before setting PRIVATEKEY.**

- x402 pay-per-call (bytebuydata): Base mainnet (eip155:8453), REAL USDC. Paid feeds settle real money — every price is quoted in the 402 challenge and listed per feed at https://x402.payperbyte.io/feeds. Example: the Merchant Screen Oracle returns a signed ALLOW/WARN/BLOCK check on a merchant's domain and payout address, backed by a signed EIP-712 attestation over the exact response bytes, run before an agent settles an x402 payment to it. Authenticity and delivery-integrity, not a correctness guarantee on the verdict itself — and on the domain, address and price you supply; it does not observe or constrain the address you ultimately settle to. Use a dedicated wallet holding only what you intend to spend.

- On-chain subscribe/publish/query layer (BYTE Library contracts + indexer): Arbitrum Sepolia testnet (chain 421614), MockUSDC. Mainnet for this layer is gated on an external security audit. The EIP-712 attestation signing domain stays anchored at 421614 regardless of which rail you paid on.

One PRIVATE_KEY serves both rails. Never reuse a key holding funds you can't afford to spend.

Quick start

npx -y byte-mcp-server

Wire it into your MCP client (Claude Desktop config below), then your agent can:

  • Discover feeds: "List the PayPerByte catalog" / "Search publishers for weather"
  • Screen a counterparty before you pay it (x402, no setup): "Screen this domain and payout address before I settle" → real USDC on Base mainnet at the price the 402 challenge quotes, signed ALLOW/WARN/BLOCK verdict from the Merchant Screen Oracle with an attestation receipt
  • Try it cheap first: "Get the weather" / "Any earthquakes over M4 today?" → real USDC at each feed's listed price (https://x402.payperbyte.io/feeds), same attestation receipt on every response — a low-cost way to see verify-before-act work before spending on a verdict
  • Subscribe to a stream (testnet): "Subscribe me to the earthquakes feed" → auto-approves MockUSDC for ongoing settlement on Arbitrum Sepolia
  • Query a fact-oracle (testnet): post a signed EIP-712 question to a registered fact-oracle publisher for an on-chain signed answer with citations — when a fact-oracle publisher is live (none is broadcasting today; the tool times out until one registers and broadcasts)

The live catalog is at x402.payperbyte.io/feeds — cryptographically attested, provenance-verifiable feeds across weather, markets, code, security, and knowledge.

Verify before acting (ForeSeal)

See the whole verify-before-act loop in one command — no install, no signup, no wallet:

npx @foreseal/demo

Shortened. The full README is on GitHub.

Nothing above is checked by us. What we check is on the safety report.

Byte Protocol: common questions

Is Byte Protocol MCP server safe?
Mostly: it is graded B (84/100). Read the Byte Protocol safety report
How do I install Byte Protocol?
It runs remotely at mcp.payperbyte.io. Add it to Claude Code, Cursor, VS Code or Claude Desktop with the snippets above, or call it through the mcp.market gateway without installing anything.
Does Byte Protocol need an API key?
Yes. The registry entry asks for PRIVATE_KEY.
Is Byte Protocol maintained?
The last commit was 37 days ago (2026-09-29). The latest release is v0.13.0.
Is Byte Protocol up?
100% of our last 28 checks got an answer. We check remote servers about four times a day.
How does Byte Protocol compare with other MCP servers?
safety score 84/100 (higher than 68% of 48,243 servers); tools 15 (the typical server has 7); tools that change things 13% (typical: 0%. Fewer write tools means less an agent can break). Full comparison.