Alphapipeline

io.github.parkyucheol-delPublished by GitHub account parkyucheol-delv1.3.0Updated Oct 24, 2026

Pay-per-call x402 API for AI trading agents: pre-trade security checks, Polymarket & HIP-4 odds.

VerifiedStreamable HTTPWeb executableFinance Security & Monitoring Data & Analytics

Server details

Identifier: io.github.parkyucheol-del/alphapipeline
Transport: Streamable HTTP
Runtime: Web executable
Trust: Verified
Published: Sep 16, 2026

Security note

MCP servers receive tool arguments from a conversation and may perform external actions. Review what a server can do before you enable it, and give it only the access it needs.

The registry verified the GitHub account parkyucheol-del for this listing. That does not show the account is the product's maker.

SourceWeft's checks cover whether the listing is complete and the endpoint answered; they do not review the server's code or what its tools do.

Add a badge to your README

Show readers this MCP server is listed on SourceWeft. The badge links to this page.

[![Listed on SourceWeft](https://sourceweft.com/badge/mcp/io.github.parkyucheol-del%2Falphapipeline.svg)](https://sourceweft.com/mcp/io.github.parkyucheol-del%2Falphapipeline?utm_source=readme&utm_medium=badge)

Overview

AI-generated overview

Pay-per-call crypto market data API for trading agents: token rug-pull and honeypot checks, DEX slippage, funding rates, and Polymarket/HIP-4 odds.

What you can do: Screen tokens before a swap: honeypot, tax, mintability, LP lock and counterfeit checks, plus a bundled diagnostic
Check DEX pool liquidity and estimated slippage, and compare CEX reference prices against DEX pools for arbitrage spreads
Read perpetual funding rates, funding APR, and audit a Hyperliquid wallet's open positions
Inspect Polymarket order books: exit capacity, order splitting, bid/ask spread, imbalance, fees and mispricing
Read Hyperliquid HIP-4 prediction-market probabilities, price ladders and mispricing, plus macro event countdowns and token unlock risk
When to use it: Useful for agents that trade or research crypto on-chain and want a pre-buy safety gate plus market, derivatives and prediction-market context in one place. Discovery and two onboarding tools are free, so it can be evaluated before paying.
Requirements: Remote MCP endpoint over streamable HTTP; no signup, API key or OAuth. Priced tool calls require an x402-capable client with a wallet that can sign USDC payments on Base mainnet; stock chat UIs generally cannot pay automatically. Network access to the hosted endpoint.

Before you install

Most tools cost $0.005 to $0.03 USDC per call, charged from a wallet on Base; a client must sign payments, so use a dedicated small wallet. Tools return raw risk numbers with no safe-to-buy verdict, and the security data comes from a single upstream (GoPlus) with no independent second opinion. Read-only: it does not execute trades or hold funds.

Installation

In SourceWeft

Open Alphapipeline in the dashboard and add it to a workspace.
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.parkyucheol-del%2Falphapipeline/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": {
    "alphapipeline": {
      "type": "http",
      "url": "https://alphapipeline-eu.onrender.com/mcp"
    }
  }
}

README

[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):

json

{  "mcpServers": {    "alphapipeline": {      "url": "https://alphapipeline-eu.onrender.com/mcp"    }  }}

{  "mcpServers": {    "alphapipeline": {      "url": "https://alphapipeline-eu.onrender.com/mcp"    }  }}

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

bash

curl -s "https://alphapipeline-eu.onrender.com/v1/security/token-risk?chain_id=8453&contract_address=0x..."# -> HTTP 402, payment terms in the `payment-required` response header (base64 JSON)# sign a payment, retry with the PAYMENT-SIGNATURE header attached -> 200 + data

curl -s "https://alphapipeline-eu.onrender.com/v1/security/token-risk?chain_id=8453&contract_address=0x..."# -> HTTP 402, payment terms in the `payment-required` response header (base64 JSON)# sign a payment, retry with the PAYMENT-SIGNATURE header attached -> 200 + data

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):

Checking live Polymarket exit-liquidity via AlphaPipeline...
Market:            will-the-fed-decrease-interest-rates-by-25-bps-after-the-october-2026-meeting-... (sell)Position size:     500 sharesExecutable:        trueBest quote:        $0.0060Avg exit price:    $0.0060Price impact:      0%Data source:       polymarket-clobLatency:           88ms
Want this for any market/size, in your own bot?-> https://github.com/parkyucheol-del/alphapipeline

Checking live Polymarket exit-liquidity via AlphaPipeline...
Market:            will-the-fed-decrease-interest-rates-by-25-bps-after-the-october-2026-meeting-... (sell)Position size:     500 sharesExecutable:        trueBest quote:        $0.0060Avg exit price:    $0.0060Price impact:      0%Data source:       polymarket-clobLatency:           88ms
Want this for any market/size, in your own bot?-> https://github.com/parkyucheol-del/alphapipeline

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:

python

# pip install "x402[https]" eth_account httpximport asyncio, osfrom eth_account import Accountfrom x402 import x402Clientfrom x402.http.clients import x402HttpxClientfrom x402.mechanisms.evm import EthAccountSignerfrom x402.mechanisms.evm.exact.register import register_exact_evm_client
API = "https://alphapipeline-eu.onrender.com"
async def is_safe_to_buy(contract_address: str, chain_id: int = 8453) -> bool:    account = Account.from_key(os.environ["EVM_PRIVATE_KEY"])  # dedicated small wallet only    client = x402Client()    register_exact_evm_client(client, EthAccountSigner(account))    async with x402HttpxClient(client) as http:        r = await http.get(f"{API}/v1/security/token-diagnostic",                            params={"contract_address": contract_address, "chain_id": chain_id})        await r.aread()        diag = r.json()  # $0.03 USDC charged on Base mainnet — no free tier for this one
    return (        diag.get("is_honeypot") is not True        and (diag.get("buy_tax_pct") or 0) <= 10        and (diag.get("sell_tax_pct") or 0) <= 10        and diag.get("liquidity_health") in ("LOCKED", "PARTIALLY_LOCKED")    )
if __name__ == "__main__":    print(asyncio.run(is_safe_to_buy("0xYourTargetTokenContract")))

# pip install "x402[https]" eth_account httpximport asyncio, osfrom eth_account import Accountfrom x402 import x402Clientfrom x402.http.clients import x402HttpxClientfrom x402.mechanisms.evm import EthAccountSignerfrom x402.mechanisms.evm.exact.register import register_exact_evm_client
API = "https://alphapipeline-eu.onrender.com"
async def is_safe_to_buy(contract_address: str, chain_id: int = 8453) -> bool:    account = Account.from_key(os.environ["EVM_PRIVATE_KEY"])  # dedicated small wallet only    client = x402Client()    register_exact_evm_client(client, EthAccountSigner(account))    async with x402HttpxClient(client) as http:        r = await http.get(f"{API}/v1/security/token-diagnostic",                            params={"contract_address": contract_address, "chain_id": chain_id})        await r.aread()        diag = r.json()  # $0.03 USDC charged on Base mainnet — no free tier for this one
    return (        diag.get("is_honeypot") is not True        and (diag.get("buy_tax_pct") or 0) <= 10        and (diag.get("sell_tax_pct") or 0) <= 10        and diag.get("liquidity_health") in ("LOCKED", "PARTIALLY_LOCKED")    )
if __name__ == "__main__":    print(asyncio.run(is_safe_to_buy("0xYourTargetTokenContract")))

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

Tool (MCP)	REST endpoint	Price	What it does
`security.token_prescreen`	`GET /v1/security/token-prescreen`	$0.01	Pre-trade check, cheapest tier — batch-screening filter: LP lock/burn status (same GoPlus call as contract_health_audit, no extra upstream cost) plus GeckoTerminal top-pool USD liquidity (same source as dex.liquidity_slippage) in one minimal response. Run this first across many candidates to cheaply drop the ones with no real liquidity or unlocked LP, then only spend `token_risk`/`contract_health_audit`/`token_diagnostic` on survivors. No honeypot/tax/mint checks and no LP-holder breakdown — see those tools for that. `liquidity_usd` is null when `chain_id` isn't mapped to GeckoTerminal (currently Base, Ethereum, BSC, Polygon, Arbitrum, Optimism, Avalanche); LP lock data is unaffected.
`security.token_authenticity`	`GET /v1/security/token-authenticity`	$0.01	Pre-trade check, cheapest tier — flags contracts impersonating a known mainstream asset (e.g. a fake "USDC"), using GoPlus's `fake_token`/`trust_list`/`honeypot_with_same_creator` fields (same GoPlus call as token-risk/contract-health-audit/token-prescreen, no extra upstream cost). `flagged_as_counterfeit: false` is not proof of authenticity — it only means GoPlus found no such flag at query time; `true_token_address` is only set when `flagged_as_counterfeit` is true. No honeypot/tax/LP checks — see `token_risk`/`contract_health_audit` for those. No Honeypot.is fallback exists for these fields.
`security.token_risk`	`GET /v1/security/token-risk`	$0.02	Pre-trade check — call before buying or swapping: GoPlus/Honeypot.is-backed contract security audit (honeypot flag, buy/sell tax, mintability, ownership renouncement, plus individual GoPlus signals — cannot_sell_all, hidden_owner, transfer_pausable, selfdestruct, is_blacklisted, slippage_modifiable, owner concentration — folded into risk_flags). Screening many candidates? `security.token_prescreen` ($0.01) is a cheaper first-pass filter before paying for this.
`security.contract_health_audit`	`GET /v1/security/contract-health-audit`	$0.02	Pre-trade check — LP (liquidity pool) lock/burn audit reusing the same GoPlus data as token-risk: flags whether liquidity is locked, burned, or freely held by a single wallet before you trust it. Screening many candidates? `security.token_prescreen` ($0.01) reuses this same LP-lock check plus a liquidity figure, for less.
`security.token_diagnostic`	`GET /v1/security/token-diagnostic`	$0.03	Pre-trade check — bundles token_risk + contract_health_audit into one call (same GoPlus data, no new upstream calls) for a single go/no-go input before a swap. No composite score or letter grade — just both tools' fields plus a deduped risk_flags union. Cheaper than calling both separately. Screening many candidates? `security.token_prescreen` ($0.01) is a cheaper first-pass filter before paying for this.
`dex.liquidity_slippage`	`GET /v1/dex/liquidity-slippage`	$0.02	GeckoTerminal-backed DEX pool liquidity and estimated trade slippage, plus fixed $1k/$5k/$10k `slippage_tiers`, `pool_fee_pct`, an `assumed_gas_cost_usd` estimate, and `quote_token_is_stablecoin` (flags when the picked pool isn't USD-quoted and an extra hop is needed) for at-a-glance depth checks. When called with `token_address`, also returns `direct_stablecoin_pool_exists` and, when the picked pool isn't USD-quoted, `alternate_direct_pool` (a different pool for the same token that is) - so you know before swapping whether a multi-hop route is actually required.
`derivatives.whale_position_audit`	`GET /v1/derivatives/whale-position-audit`	$0.02	Audits a Hyperliquid wallet address you supply: open positions, leverage, `max_leverage`, liquidation price, PnL, and `return_on_equity_pct` (the latter two Hyperliquid's own reported fields). Does not discover or rank wallets - Hyperliquid's public API has no leaderboard endpoint.
`derivatives.funding_rate`	`GET /v1/derivatives/funding-rate`	$0.01	Bybit (primary) / Binance (fallback) perpetual futures funding rate, plus `mark_price`/`index_price` (both paths) and `open_interest_usd` (Bybit path only, null on the Binance fallback).
`derivatives.funding_rate_value`	`GET /v1/derivatives/funding-rate-value`	$0.001	Cheap tier — thin wrapper around `funding_rate`: same cached call, trimmed to just `funding_rate`/`funding_rate_percentage` (no mark/index price, no open interest). No new upstream call.
`derivatives.funding_apr_matrix`	`GET /v1/derivatives/funding-apr-matrix`	$0.01	Annualizes the current funding rate into an APR and computes carry-trade breakeven days against an assumed round-trip trading cost.
`arb.spread_matrix`	`GET /v1/arb/spread-matrix`	$0.02	CEX (Coinbase spot) vs DEX (GeckoTerminal) spread calculator with gas-adjusted profitability flag, plus `pool_fee_pct` (informational - not subtracted from the spread).
`prediction.neg_risk_arbitrage`	`GET /v1/prediction/neg-risk-arbitrage`	$0.03	Detects basket arbitrage in a Polymarket neg-risk (mutually-exclusive, multi-outcome) event — a full YES basket always settles to $1, so a basket price away from $1 (after costs) is a near risk-free edge. Also returns the actual liquidity-bottleneck size executable right now (VWAP-priced, not just top-of-book), and `oldest_book_snapshot_time` (staleness bottleneck across legs). Polymarket only.
`prediction.exit_capacity_audit`	`GET /v1/prediction/exit-capacity-audit`	$0.02	Walks a Polymarket outcome's live order book to check whether a given position size can actually be filled right now, at what average price and price impact, plus `book_snapshot_time`/`tick_size`/`min_order_size`. Resolves by `token_id` or an exact `market_slug`.
`prediction.order_split_guide`	`GET /v1/prediction/order-split-guide`	$0.02	Walks a Polymarket outcome's live order book to recommend how many clips to split a large position into so each clip's own price impact stays at or under `max_price_impact_pct_per_slice` (default 1.0%), plus `full_size_price_impact_pct` as a one-shot baseline for comparison. Single-snapshot calculation — has no idea whether the book refills between clips in real trading, see the response's own `notice` field. Reuses `exit_capacity_audit`'s order-book helpers, no new upstream call. Resolves by `token_id` or an exact `market_slug`.
`prediction.bid_ask_spread_pct`	`GET /v1/prediction/bid-ask-spread-pct`	$0.001	Cheap tier — a single Polymarket outcome's live top-of-book bid/ask spread as a percentage of `mid_price`. Not a liquidity or executability measure (use `exit_capacity_audit`/`order_split_guide` for that). Reuses the same order-book fetch, no new upstream call. Resolves by `token_id` or an exact `market_slug`.
`prediction.orderbook_imbalance_ratio`	`GET /v1/prediction/orderbook-imbalance-ratio`	$0.01	A single Polymarket outcome's bid-side vs ask-side order-book depth ratio, summed within `depth_band_pct` (default 5.0%) of each side's own best quote — 0.5 = balanced, closer to 1.0 = bid-side dominant, closer to 0.0 = ask-side dominant. Purely descriptive — not a prediction of price direction, no confidence/verdict field. Reuses the same order-book fetch, no new upstream call. Resolves by `token_id` or an exact `market_slug`.
`prediction.liquidity_depth_after_haircut`	`GET /v1/prediction/liquidity-depth-after-haircut`	$0.02	A single Polymarket outcome's executable depth within `max_price_impact_pct` (default 5.0%) of the best quote, both before and after discounting the top-of-book level's size by `haircut_pct` (default 10.0%) — models best-quote cancellation risk, does not detect or flag actual spoofing (out of scope, see `architecture-roadmap.md` Phase 3). Reuses the same order-book fetch, no new upstream call. Resolves by `token_id` or an exact `market_slug`.
`prediction.polymarket_fee_estimate`	`GET /v1/prediction/polymarket-fee-estimate`	$0.01	Polymarket's own taker fee (`shares * fee_rate * price * (1 - price)`, the official bell-curve formula) for a hypothetical fill — NOT gas, slippage, or AlphaPipeline's own charge. `fee_rate` is read live from Polymarket's own `GET /fee-rate` for the exact `token_id`, never a hardcoded category table (per-category rates have changed before — see `architecture-roadmap.md` Engineering Precision Backlog item 3). Makers pay 0 everywhere; taker fee only. Omit `price` to use the live best book quote. Resolves by `token_id` or an exact `market_slug`.
`prediction.polymarket_mispricing`	`GET /v1/prediction/polymarket-mispricing`	$0.03	Monotonicity check (higher strike must not be priced above a lower strike) across Polymarket markets you assert already share the same settlement condition — this endpoint does not verify or infer that equivalence itself (Polymarket's API has no reliable field for it; see `architecture-roadmap.md` Engineering Precision Backlog item 4 and the response's own `notice`). Accepts `token_ids` or `market_slugs` (+ optional `outcomes`). Not investment advice.
`prediction.hip4_snapshot`	`GET /v1/prediction/hip4-snapshot`	$0.01	Real-time probability snapshot of Hyperliquid's HIP-4 outcome markets — crypto price binaries, sports game winners, tournament winners, Fed rate decisions, and any new market type Hyperliquid adds, all in one call. No curated market list: every `fields` value is parsed verbatim from Hyperliquid's own description string. Optional `template`/`underlying` filters narrow the result. Hyperliquid only.
`prediction.hip4_price_ladder`	`GET /v1/prediction/hip4-price-ladder`	$0.01	One underlying's HIP-4 "above $X" price-binary markets sorted into a strike ladder, each rung with its live Yes probability — read the market's implied price distribution at a glance instead of scanning `hip4_snapshot`'s raw list. Reuses `hip4_snapshot`'s cached data (no new upstream call). No volume field: Hyperliquid doesn't expose per-outcome volume for HIP-4. Required `underlying`. Hyperliquid only.
`prediction.hip4_price`	`GET /v1/prediction/hip4-price`	$0.002	Cheap tier — single-rung lookup: reuses `hip4_price_ladder`'s cached data and returns only the one rung whose strike is closest to your requested `strike`, with `matched_strike` so you can tell when no close rung exists. No new upstream call. Required `underlying`, `strike`. Hyperliquid only.
`prediction.hip4_mispricing`	`GET /v1/prediction/hip4-mispricing`	$0.02	Finds monotonicity violations among a single underlying's HIP-4 "above $X" price-binary markets: within the same expiry/period, a higher strike's Yes price should never exceed a lower strike's — any reversal is flagged with `violation_bp` and a textbook `max_riskless_profit_per_usd` (the violation size itself, before fees/slippage/execution risk — not investment advice). Reuses `hip4_price_ladder`'s cached data, no new upstream call. Only rungs sharing the exact same `(expiry, period)` are ever compared (see `settlement_condition_note`). Required `underlying`. Hyperliquid only.
`market.cycle_compare`	`GET /v1/market/cycle-compare`	$0.01	BTC/ETH price return since the current halving (2024-04-20) vs. the same elapsed days in the 2016 and 2020 post-halving cycles, plus today's real BTC dominance and DXY/US 10Y macro context. Reads a daily-refreshed cache (no live upstream call at request time). Raw price comparison, not true market-cap dominance history — see the response's own `notice` field. No ETH 2016-cycle figures (ETH didn't exist yet).
`market.oracle_gap`	`GET /v1/market/oracle-gap`	$0.01	Single-snapshot gap between Hyperliquid's mid price and its mark/oracle prices for one perpetual — the failure mode behind the 2026-10-10 Papertrade incident on HyperEVM (a protocol priced off raw mid instead of mark/oracle; an attacker moved ~$2.31B notional on Hyperliquid itself to swing the mid ~12bp, netting ~$1.28M). Returns `mid_oracle_gap_bp`/`mark_oracle_gap_bp` in basis points plus a fixed-threshold `elevated` flag (`abs(mid_oracle_gap_bp) >= alert_threshold_bp`) — not a manipulation determination. Single point-in-time snapshot, no trade-flow/volume data (Hyperliquid doesn't expose per-market volume).
`market.oracle_gap_bp`	`GET /v1/market/oracle-gap-bp`	$0.001	Cheap tier — thin wrapper around `oracle_gap`: same cached call, trimmed to just the bp gap numbers and the `elevated` flag (no absolute mid/mark/oracle prices). No new upstream call.
`calendar.macro_dday`	`GET /v1/calendar/macro-dday`	$0.01	Countdown to the nearest major US macro event (FOMC, CPI, NFP) from a static, pre-loaded calendar — no external API call, never fails on an upstream outage.
`tools.ai_markdown`	`GET /v1/tools/ai-markdown`	$0.005	Converts any webpage URL into clean, ad-free Markdown optimized for LLM context windows.
`market.kimchi_alert`	`GET /v1/market/kimchi-alert`	Free	Real-time Korea (Upbit) vs global reference price (Coinbase spot, CoinGecko fallback — not a live Binance orderbook) premium — the "kimchi premium" — with reverse-premium and 1h-surge alerts. Kept free by default as an onboarding tool: informational market context, not part of the paid pre-trade security cluster.
`unlocks.dump_risk`	`GET /v1/unlocks/dump-risk`	Free	On-chain (Sablier) proxy for token unlock/vesting dump risk, including `vesting_progress_pct` (withdrawn/deposit) showing how far along vesting already is. Kept free by default as an onboarding tool so agents can verify the service before paying for the rest.
[EXPERIMENTAL] `events.hip4_alerts`	`GET /v1/prediction/hip4-alerts/event-types` (free) · `GET /v1/prediction/hip4-alerts/subscribe` ($0.02) · `POST /v1/prediction/hip4-alerts/unsubscribe` (free)	See below	Webhook push alerts on HIP-4 probability jumps / new markets, instead of polling `hip4_snapshot` yourself. Disabled by default (`HIP4_EVENTS_ENABLED=false`) - see "Event subscriptions" below.

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:

bash

curl -G https://alphapipeline-eu.onrender.com/v1/prediction/hip4-alerts/subscribe \  --data-urlencode "webhook_url=https://webhook.site/your-id" \  --data-urlencode "secret=replace-with-a-random-32-byte-secret"# -> 402 with payment terms, same as any other endpoint here; pay, retry, get a subscription_id back

curl -G https://alphapipeline-eu.onrender.com/v1/prediction/hip4-alerts/subscribe \  --data-urlencode "webhook_url=https://webhook.site/your-id" \  --data-urlencode "secret=replace-with-a-random-32-byte-secret"# -> 402 with payment terms, same as any other endpoint here; pay, retry, get a subscription_id back

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:

Domain	Upstream(s)	Notes
`market.kimchi_alert`, `arb.spread_matrix` (CEX leg)	Upbit (KRW) + Coinbase spot, CoinGecko fallback	Not a live Binance orderbook, despite the legacy `binance_price_usdt` field name kept for backward compatibility — see `cex_reference_price_usdt`/`cex_price_source`.
`security.token_risk`, `security.contract_health_audit`, `security.token_diagnostic`, `security.token_prescreen` (LP-lock half), `security.token_authenticity`	GoPlus Security API, Honeypot.is fallback (token_authenticity has no fallback)	Same underlying GoPlus data reused across all five; no independent second opinion.
`derivatives.funding_rate`, `derivatives.funding_apr_matrix`	Bybit v5 (primary), Binance premiumIndex (fallback)	`open_interest_usd` is Bybit-only — always null on the Binance fallback path.
`derivatives.whale_position_audit`	Hyperliquid public API (`clearinghouseState`)	No leaderboard/discovery endpoint exists upstream — you must supply the wallet address.
`dex.liquidity_slippage`, `arb.spread_matrix` (DEX leg), `security.token_prescreen` (liquidity half)	GeckoTerminal	Liquidity depth is a constant-product (50:50) approximation, not per-token real reserves — disclosed via the response's own `notice` field. `token_prescreen`'s `liquidity_usd` is null for chains not mapped to a GeckoTerminal network slug (currently Base, Ethereum, BSC, Polygon, Arbitrum, Optimism, Avalanche).
`unlocks.dump_risk`	On-chain Sablier vesting streams (default, free)	VC/team classification and exact unlock timing require a paid DropsTab key (disabled by default) and are otherwise always `null` — never treat `null` as a safety signal.
`calendar.macro_dday`	Static, pre-loaded calendar	No external API call — never fails on an upstream outage, but needs manual updates as events roll off the calendar.
`prediction.neg_risk_arbitrage`, `prediction.exit_capacity_audit`, `prediction.order_split_guide`, `prediction.bid_ask_spread_pct`, `prediction.orderbook_imbalance_ratio`, `prediction.liquidity_depth_after_haircut`, `prediction.polymarket_fee_estimate`, `prediction.polymarket_mispricing`	Polymarket Gamma API (event/market metadata) + Polymarket CLOB API (order book, `GET /fee-rate`)	`book_snapshot_time`/`tick_size`/`min_order_size`/`base_fee_bp` are Polymarket's own reported values, passed through as-is.
`prediction.hip4_snapshot`	Hyperliquid public API (`outcomeMeta` + `allMids`)	No leaderboard/curated list — every market Hyperliquid currently lists shows up. The `outcome_id` → `allMids` price-key mapping is not documented by Hyperliquid and was reverse-engineered from live data (2026-09-28); disclosed via the response's own `notice` field.
`prediction.hip4_price_ladder`	Same Hyperliquid public API as `prediction.hip4_snapshot`, both calls cached	Pure re-sort/filter of `hip4_snapshot`'s own data — no separate upstream call, no volume field upstream doesn't provide it.
`market.oracle_gap`	Hyperliquid public API (`metaAndAssetCtxs`)	Mid/mark/oracle prices are Hyperliquid's own reported fields, read fresh each call (short-lived cache, `ORACLE_GAP_CACHE_TTL_SECONDS`, default 3s) since a gap check is only meaningful close to real-time. No trade-flow/volume data — Hyperliquid doesn't expose it.
`market.cycle_compare`	Yahoo Finance (`BTC-USD`/`ETH-USD` full price history, `DX-Y.NYB`, `%5ETNX`) + CoinGecko `/global` (today's dominance only)	Daily GitHub Actions cron writes a single JSON cache; the endpoint only reads that file. CoinMetrics Community (401 on everything now), CoinGecko's historical global market-cap chart (paid plans only), and CoinGecko's free Demo plan (365-day history cap) and Kraken's public OHLC (720-candle cap) were all tried and ruled out before landing on Yahoo — see `scripts/collect_btc_cycle_metrics.py`'s module docstring.
`tools.ai_markdown`	The URL you pass in	No third-party data provider — we fetch and convert the page you give us.
[EXPERIMENTAL] `events.hip4_alerts`	Same Hyperliquid public API as `prediction.hip4_snapshot`, re-polled every `HIP4_EVENTS_POLL_INTERVAL_SECONDS`	Polling + diff, not a push feed from Hyperliquid — see "Event subscriptions" above.

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.

License

See LICENSE.

Source: README.md at commit c4ca74c

Tools

market.kimchi_alert

Use this tool when evaluating Korean exchange price premiums, the 'kimchi premium', Upbit price gaps vs a global reference price, cross-border crypto arbitrage, or sudden Korea-specific price anomalies. Real-time Upbit vs Coinbase spot (CoinGecko fallback) - NOT a live Binance orderbook, despite the legacy binance_price_usdt field name kept for backward compatibility - with reverse-premium and surge alerts. Do not use for general USD spot prices or on-chain DEX swaps. Paid in USDC on Base (free while KIMCHI_ALERT_ENABLED=false).

Parameterssymbol

tools.ai_markdown

Use this tool when an agent needs to parse clean webpage article content without wasting context tokens on ads, scripts, navigation, and HTML boilerplate, or when summarizing a specific URL. Converts any URL into clean Markdown optimized for LLM context windows. Do not use for raw API endpoints or binary files (PDF/images). Paid in USDC on Base.

Parametersurlrequired

security.token_risk

Use this tool before executing any on-chain swap to verify if an ERC-20 contract is a honeypot, rug-pull risk, or has malicious buy/sell taxes and mintability backdoors. GoPlus/Honeypot.is-backed security audit for a given contract address - beyond is_honeypot, also surfaces individual GoPlus risk signals (cannot_buy, cannot_sell_all, hidden_owner, transfer_pausable, selfdestruct, is_blacklisted, slippage_modifiable, owner_percent) into risk_flags, plus is_proxy/trading_cooldown as informational-only fields (not flagged, since both are common in legitimate contracts). All of these are null when the Honeypot.is fallback path is used. Do not use for market price discovery or liquidity depth. Paid in USDC on Base.