Whale Data Mcp

io.github.predgeAIPublished by GitHub account predgeAIv0.3.0Updated Nov 1, 2026

Signed delivery verdicts for agent payments, Polymarket settlement risk and whale data, via x402.

Overview

AI-generated overview

Predge MCP server giving assistants signed delivery verdicts for agent payments plus Polymarket whale, smart-money and settlement data, paid per call in USDC.

What you can do
  • Discover endpoints, prices and schemas, and check key status or Desk config
  • Issue and re-read signed delivery verdicts for paid agent jobs, with refund recommendations and monthly reports
  • Read Polymarket whale trades, biggest bets, market movers, price/volume history and daily or category digests
  • Profile, compare and rank wallets by edge, and get smart-money consensus or single-market verdicts
  • Fetch signed resolved-outcome and sports-result attestations, plus free live UMA settlement risk
  • Verify any Predge signed record offline against the published key set
When to use it
Useful when an assistant needs to judge whether a paid API or agent job was actually delivered, or needs Polymarket whale flow, wallet track records and settlement-risk data with verifiable signatures. The free tools alone are enough for discovery, settlement risk and record verification.
Requirements
Runs locally via npx as a stdio process. Paid tools need a funded Base mainnet key in BUYER_PRIVATE_KEY and/or a Solana key in SOLANA_BUYER_SECRET holding USDC; optional PREDGE_KEY (pilot or Desk key) is sent as the x-predge-key header. MAX_PRICE_USD caps spend, X402_NETWORK selects base or base-sepolia, and network access to api.predge.io is required.
Before you install
Paid tools spend real USDC on Base or Solana mainnet, typically $0.005 to $0.03 per call, and predge_verdict costs $0.05 or $0.50 depending on payment amount; MAX_PRICE_USD defaults to $0.05 and must be raised for the large verdict route. BUYER_PRIVATE_KEY and SOLANA_BUYER_SECRET are funded wallet secrets, so use a dedicated low-balance wallet and keep them out of version control. Requests and job details go to the Predge API, and data is delayed 15 minutes.

Installation

In SourceWeft

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

Desktop only via STDIO. STDIO servers start a local process, so they need the SourceWeft desktop host.

Other MCP clients

Follow the launch instructions in the repository.

README

@predge/whale-data-mcp

MCP server that exposes the Predge API at https://api.predge.io (signed delivery verdicts for AI-agent payments, Polymarket whale trades, smart-money signals, signed attestations, and free signed UMA settlement risk) as tools. Payment is handled under the hood: each paid tool call signs a USDC micropayment via an x402 client — the agent just calls the tool and gets data back. You supply a funded buyer key.

Defaults to Base mainnet (the live Predge API is mainnet-only). Paid tools spend real USDC — typically $0.005–$0.03/call, hard-capped at MAX_PRICE_USD ($0.05 by default) before any money moves. Use a dedicated, low-balance buyer wallet.

Get a free key

Free pilot key in a minute: https://predge.io/start (no card)

With the MCP server: claude mcp add predge-whale-data -e PREDGE_KEY=pdg_pilot_... -- npx -y @predge/whale-data-mcp (no wallet needed for the calls the key covers, see Optional: a Predge key below).

First call over plain HTTP: a signed delivery verdict for a paid agent call.

bash
export PREDGE_KEY=pdg_pilot_...   # from predge.io/startcurl -s https://api.predge.io/v1/verdicts \  -H 'content-type: application/json' \  -H "x-predge-key: $PREDGE_KEY" \  -d '{"job":{"endpoint":"https://api.example.com/v1/report","expected_content_type":"application/json","required_fields":["rows"]},       "delivery":{"status":200,"headers":{"content-type":"application/json"},"body":"{\"rows\":[1]}"},       "payment":{"amount_usd":0.25,"payer":"0xBuyer","payee":"0xMerchant"}}'

The response carries verdict (delivered / not_delivered / inconclusive), reason_codes, an ed25519 attestation and a verify_url. Docs: predge.io/docs#verdicts.

No key? Pay per call over x402 instead: the same request without x-predge-key answers 402 with the price ($0.05), payable in USDC by any x402 client.

Install (one command)

Claude Code:

bash
claude mcp add predge-whale-data \  -e BUYER_PRIVATE_KEY=0xYOUR_FUNDED_BASE_MAINNET_KEY \  -e X402_NETWORK=base \  -- npx -y @predge/whale-data-mcp

Claude Desktop / Cursor / any MCP client — add to the client's MCP config:

json
{  "mcpServers": {    "predge-whale-data": {      "command": "npx",      "args": ["-y", "@predge/whale-data-mcp"],      "env": {        "BUYER_PRIVATE_KEY": "0xYOUR_FUNDED_BASE_MAINNET_KEY",        "X402_NETWORK": "base"      }    }  }}

That's it — the agent gets 25 tools (18 paid routes + 7 free tools: discovery, settlement risk, verdict re-read, verdict report, key status, Desk config, record verification). Discovery, settlement risk, verdict re-read and record verification need no key at all. No account; the buyer key pays USDC per call on Base or Solana. Fund it with a few dollars of USDC (the facilitator pays gas, so no ETH/SOL needed).

Optional: a Predge key (PREDGE_KEY)

Set PREDGE_KEY and the server sends it as the x-predge-key header on every request:

  • Pilot key, free, from https://predge.io/start (email, no card): the settlement estimate (predge_settlement_estimate) and delivery verdicts (predge_verdict) are free for 30 days, and predge_verdict_report returns your signed monthly report. After the window those calls answer 402 again; with a buyer key they then pay per call.
  • Desk key, from https://predge.io/desk (14-day trial): predge_desk_config.
bash
claude mcp add predge-whale-data -e PREDGE_KEY=pdg_pilot_... -- npx -y @predge/whale-data-mcp

The key goes first: a call it covers never pays, even with a buyer key set. Without a key or a buyer wallet, a paid tool returns the API's 402 explanation (price, networks, how to pay, where to get a pilot key) instead of failing opaquely. The key is never logged and never copied into a tool result.

ElizaOS — add to your character file (via @fleek-platform/eliza-plugin-mcp):

json
{  "plugins": ["@fleek-platform/eliza-plugin-mcp"],  "settings": {    "mcp": {      "servers": {        "predge": {          "type": "stdio",          "command": "npx",          "args": ["-y", "@predge/whale-data-mcp"],          "env": { "BUYER_PRIVATE_KEY": "0xYOUR_FUNDED_BASE_MAINNET_KEY", "MAX_PRICE_USD": "0.05" }        }      }    }  }}

Set MAX_PRICE_USD to hard-cap spend — any call above it is refused before payment. Full integration guide (ElizaOS, Claude, raw x402 for non-MCP stacks, spend caps): https://predge.io/docs#whale-data

Tools

ToolPriceReturns
predge_list_endpointsfreeAPI description + every endpoint with its price/schema (call first)
predge_settlement_riskfreeSigned live UMA settlement risk for one Polymarket market, read from Polygon: UMA state, current proposal + challenge window, every dispute, UMA-vote status, bulletin-board updates, on-chain resolution, risk_level (ok|watch|caution|resolved), segment_dispute_rate, settlement_estimate_available. The settlement_estimate itself is paid: predge_settlement_estimate. The tool re-verifies the ed25519 signature and returns { verification, record }. Param: market (condition id, numeric market id, or slug). 60 req/min per IP
predge_settlement_estimate~$0.02; free with a pilot keySame signed settlement-risk record with settlement_estimate (statistic from 2026 Polymarket UMA disputes, not advice). GET /v1/settlement-risk/:market/estimate. Check settlement_estimate_available in the free record first. Returns { verification, record }. Param: market
predge_verdict ⭐$0.05 / $0.50; free with a pilot keyDelivery verdict: was the paid job delivered? Send job (what was promised: endpoint, expected_content_type, json_schema, required_fields, max_latency_ms, expected_sha256…), delivery (evidence: status, headers, body or body_sha256, timing), payment (amount_usd, tx_hash, network, payer, payee), optional agent / provider_agent (id, version, operator, authorization_ref). payment.amount_usd < 1 → POST /v1/verdicts ($0.05), ≥ 1 → POST /v1/verdicts/large ($0.50; paying it over x402 needs MAX_PRICE_USD ≥ 0.5). Returns a signed verdict (delivered | not_delivered | inconclusive), per-check results, reason codes and a refund recommendation, as { verification, record }
predge_get_verdictfreeGET /v1/verdicts/:id: re-read a stored signed verdict, re-verified. Param: id (vrd_ + 24 chars)
predge_verdict_reportfree, needs PREDGE_KEYGET /v1/verdicts/report: signed monthly dispute-handling report for the verdicts your key requested (counts, refund recommendations, reason codes, time to verdict, verdict ids). Params: month (YYYY-MM), merchant_id, limit, cursor, sample
predge_key_statusfree, needs PREDGE_KEYGET /v1/me: your key's plan, quota and pilot expiry
predge_desk_configfree, needs a Desk keyGET /v1/desk/config: watched wallets, alert targets (webhook, Telegram), plan status
predge_verify_recordfreeOffline check of any Predge signed record (predge-attest-v1): C(payload) == canonical, sha256(canonical) == content_hash, ed25519 signature, envelope_signature, and signer listed active in predge-keys.json. Param: record (JSON string)
predge_whales_latest~$0.005Latest whale trades ≥$10k (15-min delay). Param: limit (1-100)
predge_whale_market~$0.017-day whale activity for one market. Param: condition_id
predge_signals_daily~$0.0224h digest: top markets, net flow, largest bets
predge_wallets_leaderboard~$0.01Wallets ranked by edge over resolved markets. Params: window (7d|30d), limit
predge_wallet_profile~$0.01Wallet score, win rates, categories, last 20 trades. Param: address
predge_markets_movers~$0.005Largest YES-price moves. Param: window (1h|6h|24h)
predge_signals_consensus~$0.03Edge-verified smart-money net flow + direction per market
predge_attest ⭐~$0.02Flagship. Resolved-outcome attestation — the settled truth for a market (resolved, resolution, resolved_at). Optional side (yes|no) checks whether a past signal/win-rate claim was actually right. Params: condition_id, side
predge_sports_attest ⭐~$0.02Flagship. Ed25519-signed settled game outcome (winner, final score, completed) from ESPN, verifiable offline against Predge's published key. Optional winner (team abbr) → correct. Settle bets / prove a track record on tamper-evident truth. Leagues: nba, wnba, nfl, college-football, mlb, nhl, mls, epl, champions-league, laliga. Params: league, event_id, winner
predge_bets_biggest~$0.005Top-20 largest single trades across all markets. Param: window (24h|7d)
predge_signals_daily_category~$0.0124h digest scoped to one category. Param: category
predge_signals_consensus_category~$0.02Consensus scoped to one category. Param: category
predge_signals_market~$0.01Single-market smart-money verdict ("trust this move?"). Param: condition_id
predge_wallet_history~$0.02Wallet trade history + running win-rate & PnL curve. Params: address, window (30d|90d|all)
predge_wallets_compare~$0.02Compare 2-10 wallets side-by-side + market overlap. Param: addresses
predge_market_history~$0.01Price/volume history for one market. Params: condition_id, window (7d|30d|all)

Every paid result includes a note with the on-chain settle tx. Not exposed as tools (raw x402/HTTP reaches them; see predge_list_endpoints): the /v1/markets/:id/edge polling pulse, the /v1/onchain/* routes, and the signed-calls / stakes / track-record routes. Paused routes (503 signed_wallet_outputs_paused) have no tool: the wallet track-record attestation /v1/wallets/:address/attest (the predge_wallet_attest tool was removed in 0.3.0), /v1/onchain/pm-activity, /v1/onchain/pm-flows and the free /v1/signal/:address.

Verifying signed records yourself

Every Predge signed record carries an attestation envelope. The rule is published at data.predge.io/canonicalization.md: canonical is the payload as JSON with keys sorted at every level and no whitespace; content_hash = sha256(canonical); signature is ed25519 over the UTF-8 bytes of canonical; the signer must be an active key in https://api.predge.io/.well-known/predge-keys.json (current attestation kid 3b6551a6439b9bda; 13fa3d18a369e6c7 was revoked on 21 Oct 2026). src/verify.ts implements this with node:crypto only.

Config (env)

Paid tools need a funded key for at least one rail — Base (BUYER_PRIVATE_KEY) and/or Solana (SOLANA_BUYER_SECRET). Every paid route's 402 offers both networks; the client pays on whichever it holds a key for (cheapest when both). The facilitator pays the network fee on either rail — the wallet needs USDC only.

VarDefaultNotes
PREDGE_KEY—Optional. Pilot key (predge.io/start) or Desk key (predge.io/desk), sent as x-predge-key on every request. Never logged. See above.
BUYER_PRIVATE_KEY—Funded Base-mainnet EVM key (0x…) for the Base rail.
SOLANA_BUYER_SECRET—Optional. Funded Solana-mainnet key (64-number JSON array or base58) for the Solana rail.
X402_NETWORKbaseBase network: base = mainnet (real USDC), base-sepolia only against a testnet deployment.
X402_SOLANA_NETWORKmatches X402_NETWORKsolana (mainnet) or solana-devnet.
SOLANA_RPC_URL@x402/svm defaultOptional custom Solana RPC (public mainnet-beta is rate-limited).
PREDGE_BASE_URLhttps://api.predge.ioOverride to point at another deployment. PREDGE_API_URL is accepted as an alias. Signatures are always checked against the key set on api.predge.io.
MAX_PRICE_USD0.05Any call priced above this is refused before paying.
PREDGE_MCP_USER_AGENTpredge-whale-data-mcp/<version>Sent on every request (lets the API attribute MCP traffic).

predge_list_endpoints, predge_settlement_risk, predge_get_verdict and predge_verify_record work without any key.

Upgrading from 0.1.10 or older: those versions default to a decommissioned API host and every call fails with 404. Upgrade to 0.2.0 (npx -y @predge/whale-data-mcp@latest), or set PREDGE_BASE_URL=https://api.predge.io.

Testnet

To exercise the payment path without real money, point PREDGE_BASE_URL at a Base-Sepolia deployment of the API and set X402_NETWORK=base-sepolia; fund the buyer from faucet.circle.com. (The public prod API is mainnet-only, so testnet needs your own deployment.)

Safety

  • Price cap — MAX_PRICE_USD is enforced in the payment selector, so an over-cap call is refused before any money moves (no wasted request).
  • Network guard — the client only pays a requirement on the configured network; it won't accidentally settle a mainnet requirement while in testnet mode (or vice-versa).
  • No key handling beyond env — the server reads BUYER_PRIVATE_KEY from env, never logs it, and never sends it anywhere but the local signer. Use a dedicated low-balance wallet and keep the key out of version control. PREDGE_KEY is only ever placed in the x-predge-key request header to the Predge API; it is never logged, and an API error that echoes it is redacted.

Run from source

bash
git clone https://github.com/predgeAI/whale-data-mcp.gitcd whale-data-mcp && npm install && npm run build# then point your MCP client's "command" at node with args ["/abs/path/whale-data-mcp/dist/index.js"]

Verify locally

bash
npm test                                               # unit tests (no network, no payment)npm run inspect                                        # list tools (no payment)node dist/dev-list-tools.js predge_list_endpoints      # free call against prodnode dist/dev-list-tools.js predge_settlement_risk '{"market":"<condition id or slug>"}'   # free, signed# paid call (spends real USDC on mainnet):BUYER_PRIVATE_KEY=0x… X402_NETWORK=base node dist/dev-list-tools.js predge_whales_latest '{"limit":2}'

Source: README.md at commit b78c30e

Tools

25

predge_list_endpoints

List Predge endpoints & prices (free)

Free. Returns the Predge API description, network, payTo, and every endpoint with its price and what it returns. Call this first to see what's available before paying.

Takes no parameters.

predge_whales_latest

Latest whale trades

PAID (~$0.005). Latest Polymarket whale trades ≥$10k notional (15-min delay): market, side, size, price, wallet address + Predge wallet score. Param: limit (1-100, default 50).

Parameterslimit

predge_whale_market

Whale activity for one market

PAID (~$0.01). 7-day whale activity + aggregates (volume, YES/NO split, net flow, unique wallets) for one Polymarket market. Param: condition_id.

Parameterscondition_idrequired

predge_signals_daily

24h whale digest

PAID (~$0.02). 24h digest: top markets by whale volume, net flow, largest single bets, totals.

Takes no parameters.

predge_wallets_leaderboard

Wallet win-rate leaderboard

PAID (~$0.01). Top wallets over resolved markets, ranked by edge (win rate vs. entry price), not raw win rate. Params: window (7d|30d, default 30d), limit (1-100, default 50).

Parameterslimitwindow

predge_wallet_profile

Wallet profile

PAID (~$0.01). One wallet's profile: Predge score, win rates (7d/30d), favorite categories, last 20 trades (15-min delay). Param: address (0x…).

Parametersaddressrequired

predge_markets_movers

Largest price movers

PAID (~$0.005). Largest YES-price moves across active markets (from trade prints). Param: window (1h|6h|24h, default 6h).

Parameterswindow

predge_signals_consensus

Smart-money consensus (premium)

PAID (~$0.03, premium). Per active market with whale activity in 24h: net flow of smart-money wallets (score > 70), YES/NO volume, and a direction verdict.

Takes no parameters.

predge_attest

Outcome attestation — verified settled truth (flagship)

PAID (~$0.02). Resolved-outcome ATTESTATION for one Polymarket market: the SETTLED truth straight off the market row — resolved (bool), resolution (yes|no|null), resolved_at, and outcome_verified:{resolution:true}. Pure outcome-verified data — no modeled estimate anywhere. Optional side (yes|no): adds queried_side and correct (true iff side matches the resolved outcome) — use it to VERIFY whether a past signal, call, or advertised win-rate was actually right. Unknown/unresolvable market returns null and is NOT charged. Params: condition_id, side.

Parameterssidecondition_idrequired

predge_sports_attest

Sports outcome attestation — signed settled game result (flagship)

PAID (~$0.02). Ed25519-SIGNED settled game outcome for one finished match — winner, final score, completed(bool), teams, scheduled time — sourced from ESPN and signed with Predge's published key, so it VERIFIES OFFLINE (no trust in this API): re-check the signature against the pubkey at data.predge.io/.well-known/predge-attest.json. Use it to settle bets, prove a track record, or ground a wager on a tamper-evident result. Optional winner (team abbreviation e.g. 'LAL'): adds queried_winner and correct (true iff it matches the settled winner). Unknown league or unfinished/unknown event returns null and is NOT charged. Leagues: nba, wnba, nfl, college-football, mlb, nhl, mls, epl, champions-league, laliga. Params: league, event_id (provider event id), winner.

Parametersleaguerequiredwinnerevent_idrequired

predge_bets_biggest

Biggest single bets

PAID (~$0.005). Top-20 largest single trades across all Polymarket markets in the window (market, side, size, price, wallet + score). Param: window (24h|7d, default 24h).

Parameterswindow

predge_signals_daily_category

24h digest for one category

PAID (~$0.01). The 24h whale digest scoped to one market category (e.g. politics, economics, sports). Unknown category → 404 (not charged) with the known_categories list. Param: category.

Parameterscategoryrequired

predge_signals_consensus_category

Smart-money consensus for one category

PAID (~$0.02). Edge-verified smart-money consensus (net flow + direction) scoped to one category. Unknown category → 404 (not charged) with known_categories. Param: category.

Parameterscategoryrequired

predge_signals_market

Single-market smart-money verdict

PAID (~$0.01). Single-market smart-money VERDICT — the "should you trust this move?" decision for one market: edge-verified smart flow, direction and confidence. Param: condition_id.

Parameterscondition_idrequired

predge_wallet_history

Wallet trade history + PnL curve

PAID (~$0.02). One wallet's trade history with a running win-rate and modeled-PnL curve. Params: address (0x…), window (30d|90d|all, default 30d).

Parameterswindowaddressrequired

predge_wallets_compare

Compare wallets side-by-side

PAID (~$0.02). Side-by-side comparison of 2-10 wallets (scores, win rates, modeled PnL) plus their market overlap. Param: addresses (2-10 0x… addresses).

Parametersaddressesrequired

predge_market_history

Market price/volume history

PAID (~$0.01). Price/volume history for one Polymarket market in daily buckets (price normalized to the YES side) plus recent prints. Params: condition_id, window (7d|30d|all, default 30d).

Parameterswindowcondition_idrequired

predge_settlement_risk

Settlement risk — signed live UMA dispute status (free)

FREE, no key or payment. Live UMA settlement risk for one Polymarket market, read from UMA's Optimistic Oracle and Polymarket's UMA CTF adapter on Polygon: uma_state, current proposal and challenge window, every dispute, whether it went to a UMA vote, bulletin-board updates, on-chain resolution, risk_level (ok|watch|caution|resolved) with a one-line recommendation, plus the segment_dispute_rate statistic and a settlement_estimate_available flag. The settlement_estimate itself is NOT in this free record: it is sold by predge_settlement_estimate (GET /v1/settlement-risk/:market/estimate, ~$0.02). The record is ed25519-signed (predge-attest-v1); this tool re-checks the signature, content hash and signer key and returns the result under `verification`. A dispute blocks a proposal; it does not by itself change the outcome. 404 unknown_market and 422 unsupported_* are NOT 'no risk' answers. Rate limit 60/min per IP. Param: market (condition id 0x+64 hex, numeric market id, or slug).

Parametersmarketrequired

predge_settlement_estimate

Settlement risk + settlement_estimate — signed (paid)

PAID (~$0.02 via x402). The same signed live UMA settlement-risk record as the free predge_settlement_risk tool, WITH settlement_estimate: a statistic computed from 2026 Polymarket UMA disputes (market price before the first dispute + market type). A statistic, not advice. GET /v1/settlement-risk/:market/estimate. The tool re-checks the ed25519 signature and returns `{ verification, record }`. Call predge_settlement_risk first (free) and check settlement_estimate_available before paying. With PREDGE_KEY set to a pilot key from https://predge.io/start it is free for 30 days. Param: market (condition id 0x+64 hex, numeric market id, or slug).

Parametersmarketrequired

predge_verify_record

Verify a Predge signed record (free, offline)

FREE. Checks a Predge signed record (predge-attest-v1) without trusting the API: payload re-canonicalises to `canonical`, sha256(canonical) == content_hash, ed25519 signature over canonical, envelope_signature when present, and that public_key is an active key in api.predge.io/.well-known/predge-keys.json (the only network call; it is cached). Works on responses from predge_settlement_risk, predge_attest, predge_sports_attest, predge_verdict, predge_get_verdict, or a bare `attestation` envelope. Param: record (the JSON, as a string).

Parametersrecordrequired

predge_verdict

Delivery verdict — was the paid job delivered? (signed)

PAID: $0.05 when payment.amount_usd < 1 (POST /v1/verdicts), $0.50 when >= 1 (POST /v1/verdicts/large); the tool picks the route. FREE with PREDGE_KEY set to a pilot key (https://predge.io/start) inside its 30-day window. Send what was promised (job: endpoint, expected content type, JSON Schema, required fields, max latency, expected sha256), the delivery evidence (status, headers, body or body_sha256, timing) and the payment reference (amount_usd, tx_hash, network, payer, payee), optionally the buyer and provider agent identities (id, version, operator, authorization_ref). Returns an ed25519-signed verdict (delivered | not_delivered | inconclusive), per-check results, reason codes and a refund RECOMMENDATION (the merchant honours it; nothing is refunded automatically). Deterministic checks, no LLM. The tool re-checks the signature and returns `{ verification, record }`; re-read later for free with predge_get_verdict. Paying the $0.50 tier over x402 needs MAX_PRICE_USD >= 0.5. Without a key or buyer wallet the result is the API's 402 explanation (price and how to pay).

Parametersjobrequiredagentpaymentrequiredbuyer_iddeliveryrequiredmerchant_idprovider_agent

predge_get_verdict

Read a signed delivery verdict by id (free)

FREE, no payment. GET /v1/verdicts/:id: the stored signed verdict issued by predge_verdict, byte-identical in content. The tool re-checks the ed25519 signature and returns `{ verification, record }`. 404 verdict_not_found for an unknown id. Param: id (vrd_ + 24 characters).

Parametersidrequired

predge_verdict_report

Monthly signed dispute-handling report (needs PREDGE_KEY)

FREE for a key holder, counts as one call against the key's daily quota. GET /v1/verdicts/report: the verdicts requested with PREDGE_KEY in one UTC month (optionally one merchant_id): counts by outcome, refund recommendations (count, total USD), top reason codes, median/p95 time to verdict, verdict ids with verify URLs (paginated, next_cursor), a sample and the methodology. Signed; the tool re-checks the signature. Params: month (YYYY-MM), merchant_id, limit (1-1000, default 100), cursor, sample (0-20, default 5).

Parameterslimitmonthrequiredcursorsamplemerchant_id

predge_key_status

PREDGE_KEY status: plan, quota, expiry (needs PREDGE_KEY)

FREE. GET /v1/me with PREDGE_KEY: the key's plan, daily quota and use, and when the pilot window ends.

Takes no parameters.

predge_desk_config

Desk config: watched wallets and alert targets (needs a Desk key)

FREE with a Desk key in PREDGE_KEY (https://predge.io/desk, 14-day trial). GET /v1/desk/config: the Polymarket wallets the Desk watches, where settlement alerts go (webhook, Telegram) and the plan status (trial, paid_until). Read only.

Takes no parameters.

Version history

5
  1. v0.3.0LatestNov 1, 2026
  2. v0.2.2Oct 18, 2026
  3. v0.2.1Oct 17, 2026
  4. v0.1.11Oct 3, 2026
  5. v0.1.10Sep 16, 2026

Score

90% 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 days25 pts
  • Auth declared10 pts

    Declare the credential headers in the registry entry, or keep the endpoint answering the probe so its auth can be classified.

  • Tools listedRequired15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts