[AlphaPipeline banner]
AlphaPipeline
A pre-flight safety gate for on-chain trading agents — rug-pull/honeypot checks before you buy, plus market/derivatives data — pay-per-call ($0.005–$0.03 USDC), no signup, no API key, no OAuth. Check a token for honeypot/tax/liquidity risk before a swap, or pull funding rates, DEX slippage, Korea price premiums, Polymarket arbitrage signals, and Hyperliquid HIP-4 prediction-market odds. Authenticate and pay in a single request via the x402 protocol (HTTP 402) on Base, or call it as a remote MCP server from Claude Desktop, Cursor, or any MCP client.
[Smithery]
[x402 Bazaar]
[Glama AI]
Why AlphaPipeline
AlphaPipeline is a machine-first data API. Every endpoint is metered per call using x402: a request without a payment header gets back a standard HTTP 402 response describing exactly how to pay (asset, amount, network, recipient). No account creation, no dashboard, no API key issuance — sign, retry the request with the payment attached, and you get the data back in the same request/response cycle.
It is also exposed as a remote MCP server (POST /mcp) so agent frameworks (Claude Desktop, Cursor, LangChain, CrewAI, and anything else that speaks MCP) can discover and call it with zero custom integration code.
The security cluster is the most battle-tested part of this API. security.token_risk, security.contract_health_audit, and security.token_diagnostic have been run as a live pre-buy safety gate ahead of real on-chain swaps on Base — not just informational data, but an actual pass/fail input wired into a trading pipeline before it risked funds. None of the three return a qualitative verdict field (no safe_to_execute: true/false) — they return raw GoPlus/Honeypot.is numbers and leave the buy/no-buy decision to your own code.
- Discovery is always free.
initialize and tools/list never require payment — browse the full tool catalog before you decide to pay.
- Two tools are permanent free onboarding endpoints (
unlocks.dump_risk and market.kimchi_alert, see below) so an agent can verify connectivity, latency, and response schema before it starts paying for the security cluster and the rest.
- Settlement is Coinbase CDP (Developer Platform) Facilitator on Base mainnet (
eip155:8453), asset USDC (0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913).
The endpoints have not been reviewed by Coinbase — please ensure you trust them prior to sending funds.
Quickstart — Remote MCP
Add this to your MCP client's config (Claude Desktop claude_desktop_config.json, Cursor .cursor/mcp.json, or equivalent):
tools/list works immediately with no payment. tools/call on a priced tool requires an x402-aware client that can sign and retry a payment (a wallet-holding bot/agent client — most stock chat UIs cannot pay automatically). See examples/ for a working Python client using the official x402 SDK.
Quickstart — Plain REST / x402
Note for client authors: this server speaks x402 v2 — the 402 response body is an empty {}; the actual payment terms (accepts array, price, asset, pay-to address) are base64-JSON in the payment-required response header, not the body. A client written against the older body-shaped convention will get an empty object with no error, not a loud failure. Decode the header instead.
Note on unlocks.dump_risk and market.kimchi_alert: both are intentionally free (no x402 payment required) as onboarding tools — they're informational market-context signals, not part of the validated pre-trade security cluster (security.token_risk, security.contract_health_audit, security.token_diagnostic), which remains paid. If a third-party discovery catalog (e.g. x402 Bazaar) still shows a stale non-zero price for either from before this change, treat this server's own / response and MCP tools/list output as the source of truth — they always reflect the live price.
Note on tool names: MCP tool names use a domain.tool_name dot-notation (e.g. market.kimchi_alert) so the tool list forms a navigable tree by domain. The REST paths under /v1/<domain>/... are unaffected by this and remain stable.
Full protocol reference: /llms.txt · x402 docs
Try it now — no wallet, no signup, no payment
Before wiring up a paying client, run check-my-slippage to see this service return real, live data against a production endpoint:
Real output (captured 2026-09-18, straight from production — not a mocked sample):
This calls the free, rate-limited (10/min per IP) GET /v1/prediction/preview-slippage — no payment header, no query params, always runs against a fixed benchmark market so you can judge data quality before paying for prediction.exit_capacity_audit, which takes any market/size you supply. If npx check-my-slippage doesn't resolve on your machine, call the endpoint directly instead: curl https://alphapipeline-eu.onrender.com/v1/prediction/preview-slippage, or run it from source: node check-my-slippage/bin/index.js from a clone of this repo.
Copy-paste client — pre-flight safety gate before a DEX buy
If you're building a sniping/discovery bot that buys new tokens on Base, this is the pattern our own dogfooding bot (alphapipeline-dogfood-bot) uses as a hard, non-bypassable gate before every on-chain purchase: pay $0.03 for security.token-diagnostic, then apply your own thresholds to the raw fields it returns (this server never returns a safe_to_buy: true/false verdict — see Why AlphaPipeline). Adapted from examples/client_example.py:
Tune the thresholds (buy/sell tax %, which liquidity_health values you accept, risk_flags_count, etc.) to your own risk tolerance — the full field list is in the security.token-diagnostic schema below. This is exactly the logic our dogfooding bot runs on every candidate before it will spend real USDC.
Tools / Endpoints
Every response is timestamped in both UTC and KST, and every priced endpoint's payment prompt reads "Paid in USDC on Base." so a human looking at the 402 screen in a browser isn't left guessing which chain's USDC to send.
Event subscriptions (webhook push) — EXPERIMENTAL
2026-09-30 addition, modeled loosely on a still-draft MCP Events extension
(github.com/modelcontextprotocol/experimental-ext-triggers-events — not an
official spec yet, request/response shape may change). Instead of polling
GET /v1/prediction/hip4-snapshot yourself, you can register a webhook and
get pushed a Standard Webhooks-signed (webhook-id / webhook-timestamp /
webhook-signature, HMAC-SHA256 over "{id}.{timestamp}.{body}") POST when a
HIP-4 outcome's probability moves by at least a threshold, or a new HIP-4
market shows up.
Honest caveats before you rely on this:
- It's polling, not a real push feed. Hyperliquid's HIP-4 has no
webhook/streaming API, so under the hood this server re-fetches
get_hip4_snapshot() every HIP4_EVENTS_POLL_INTERVAL_SECONDS (default
300s = 5 min) and diffs it. A jump can be reported up to that long after
it actually happened.
- Disabled by default (
HIP4_EVENTS_ENABLED=false). The subscribe route
isn't even registered with the payment middleware while disabled, and the
handler itself double-checks and returns 503 — so you can never be
charged for a subscription that will never deliver anything.
- Subscriptions may not survive a restart. They're persisted to a local
JSON file (
HIP4_EVENTS_DATA_FILE, default data/hip4_event_subscriptions.json),
which is fine for a single long-running Render instance but is lost on a
disk reset. Not backed by a real database (yet).
hip4.resolving (resolution/settlement-imminent) is not implemented -
Hyperliquid's outcomeMeta doesn't expose a verified resolution timestamp,
and this project's policy is never to fake a field it can't back with real
data. Only hip4.prob_jump and hip4.market_created are live.- MCP clients get the same three operations as
events/list /
events/subscribe / events/unsubscribe JSON-RPC methods on /mcp
(declared under the experimental capabilities.extensions["io.modelcontextprotocol/events"]
key) - events/subscribe self-calls the same paid REST route internally,
so pricing/payment is identical either way.
- Optional noise filter (
HIP4_EVENTS_CLEF_FILTER_ENABLED, default false).
When on, each hip4.prob_jump candidate is scored by Cloudflare Workers
AI's clef-flash decision model (needs CLOUDFLARE_ACCOUNT_ID /
CLOUDFLARE_API_TOKEN) before delivery; candidates scored below
HIP4_EVENTS_CLEF_SIGNAL_THRESHOLD (default 0.3) are not sent. No
trading-volume or orderbook-depth data goes into that score - Hyperliquid's
public HIP-4 API doesn't expose either - so it's reasoning from the
probability move alone. If the Cloudflare call fails or the credentials
are missing, this fails open: the event is delivered anyway, just
without the extra clef_signal field it would otherwise carry.
Quick test once HIP4_EVENTS_ENABLED=true is set and deployed:
Note: this is GET with query parameters, not POST with a JSON body -
see the note on secret in the endpoint description for the resulting
trade-off (it travels in the URL query string).
Data sources
Every number returned is either passed through unchanged from one of these upstreams, or a deterministic calculation on top of them — never a third-party estimate presented as our own:
In progress — stock discrepancy feed (4-week data trial, started 2026-10-08)
Collecting hourly, not selling yet. scripts/collect_stock_discrepancy.py runs via .github/workflows/stock-discrepancy-collect.yml once an hour and appends to data-public/stock_discrepancy_log.jsonl (not data/ — that directory is gitignored for HIP-4 webhook secrets; this data has nothing sensitive in it). Nothing here is a paid endpoint — this is purely assembling the evidence to decide whether it should become one.
What's tracked: last regular-session close, Base B20 token price (Aerodrome, via GeckoTerminal), Hyperliquid HIP-3 stock perp mark price + funding, and the discrepancy % between them, per symbol, per hour. Symbol list: NVDA, AAPL, META, GOOGL — not TSLA/MSTR/COIN, which an earlier brief named but which don't have a confirmed Coinbase B20/cbStock token on Aerodrome as of this writing (re-check before adding them back in).
Launch/hold decision, due ~2026-11-05 (4 weeks from start) — needs 2 of 3 to clear:
- Weekend discrepancy direction (Friday close → Sunday night) matches the following Monday's opening-gap direction ≥65% of the time (sample: 4 weekends × symbol count, roughly 16-20 data points).
- A discrepancy >1% occurs at least once per weekend, across any symbol — this is what makes an alert product viable in the first place.
- Data gaps (
data_gap: true rows — pool illiquidity, upstream API errors) stay ≤10% of all rows.
If it doesn't clear 2 of 3: don't force a paid launch on a thin signal. Turn it into a free public dashboard instead and use it as a traffic funnel into the rest of AlphaPipeline.
Secondary, free feed: the same cron also snapshots Kalshi's KXBTC15M 15-minute/hourly crypto prediction markets (public, no-auth API) into data-public/kalshi_btc15m_log.jsonl, to compare against prediction.hip4_snapshot's own BTC probability later. No extra infrastructure cost; not part of the launch/hold decision above.
New sub-feed, started 2026-10-26 — EQX spot vs Hyperliquid perp gap: EQX Labs listed 11 tokenized US stocks/ETFs (EQSPY, EQQQQ, EQAAPL, EQAMZN, EQGOOG, EQMETA, EQMSFT, EQNVDA, EQTSLA, EQMU, EQSPCX) as native Hyperliquid HIP-1 spot tokens on 2026-10-26 22:30 KST. Unlike the Base-vs-Hyperliquid comparison above (two different chains, bridge/settlement noise included), this is spot and perp on the same HyperCore venue, so the gap is a cleaner read on pure after-hours arbitrage-unavailability. Same hourly cron now also writes data-public/eqx_gap_log.jsonl (collect_eqx_gap_rows() in the same script). Not a paid endpoint yet — watching whether the after-hours/weekend gap is consistently larger than the regular-hours gap before deciding. No official EQX token ID registry was public at launch, so rows are matched by token name only (EQ + ticker) — revisit once EQX publishes IDs.
Disclaimer
AlphaPipeline provides quantitative market data and analytics for informational and research purposes only. It does not execute trades, place orders, hold custody of user funds, or provide brokerage/betting/gambling services of any kind — it is a read-only data layer. Users are solely responsible for ensuring their use of this data complies with the laws and regulations applicable in their own jurisdiction.
Links
License
See LICENSE.
