@madeonsol/plugin-robinhood-chain

🤖 Robinhood Chain API · 📚 API docs · 💰 Free API key · 🤖 ElizaOS

ElizaOS plugin for the Robinhood Chain API — EVM-native, on-chain trading intelligence for Robinhood Chain (chain id 4663). Give your ElizaOS agent live KOL trades, KOL coordination and first touches, token discovery and batch lookups, launch-bundle detection, buyer-quality scoring, deployer reputation with trajectory/history/alerts, the DEX trade tape, smart-money wallet rankings, and the RHC rule engine — all from MadeOnSol's self-hosted RHC node.

0.8.1 — version alignment with the wider RHC SDK release: WebSocket stream tokens (POST /api/v1/stream/token) never expire since 2026-08-27 — the same token comes back on every call, expires_at / next_refresh_at are always null, and only an explicit {"rotate": true} replaces one. This plugin's actions are REST-only and mint no stream token, so nothing here changed behavior.

0.5.0 — version alignment with the wider RHC SDK release: the stream channel names were corrected in the TS/Python/Rust SDKs (the RHC firehose channel is rhc:dex_trades; the server accepts rhc:trades only as a deprecated alias of it). This plugin's actions are REST-only, so nothing here changed behavior.

Server update 2026-10-04 (no package change needed): RHC copy-trade rules follow any valid source wallet. source_wallets no longer have to be tracked KOL wallets (/rhc/kol/wallets): any valid 0x wallet fires, KOL membership is optional enrichment, and copy-trade sources do not use Wallet Tracker quota. Each rule reports source_admission (any_wallet) and operational_state (eligible, or an infrastructure state monitoring_pending / monitoring_unavailable / source_capacity_unavailable). source_wallets_tracked / source_wallets_untracked, no_tracked_sources and the untracked_source_wallets warning are legacy, still filled. Existing rules work without editing. Limits are unchanged: PRO 3 rules × 5 wallets, ULTRA 20 × 50, BUSINESS 100 × 250.

New in 0.15.1: Deployer Hunter v2 text. GET_RHC_DEPLOYER_PROFILE, GET_RHC_DEPLOYER_HISTORY and GET_RHC_DEPLOYER_LEADERBOARD print organic runners over resolved launches (lifetime and recent rate, 1-hour survival, manipulation status, tier gates) when the API answers in the v2 contract (rule_version "v2.0"), and the v1 graduation/runner text otherwise. Before 0.15.1 the profile action failed when launchpads was null (about 1 in 5 RHC deployers). content still carries the full API response.

New in 0.15.0: bundle clusters, bundle share now, KOL trades per token, scouts and developer activity. Five actions + client methods (keyed msk_ API). GET_RHC_TOKEN_BUNDLES (client.getTokenBundles(address, params), PRO+): every block in a 1h/6h/24h window where at least min_wallets distinct effective trading accounts bought, launch and later; summary.baseline shows buys per active block, so a cluster is evidence, not a verdict. GET_RHC_TOKEN_BUNDLE_SHARE (client.getTokenBundleShare(address, params), PRO+): bundled_pct_of_supply_now from balanceOf on our node; null with held_now.incomplete_reason unless every wallet was read. GET_RHC_TOKEN_KOL_TRADES (client.getTokenKolTrades(address, params), BASIC+ with a 5-minute delay and 20 rows; include_balances is PRO+ and never reports a failed read as 0). GET_RHC_KOL_SCOUTS (client.getKolScoutLeaderboard(params), PRO+): KOLs whose first touches drew other KOLs within 4 hours, 30 days. GET_RHC_DEPLOYER_ACTIVITY (client.getDeployerActivity(address, params), PRO+): a developer's launches and own-token buys/sells as one paged timeline (30 days by default, at most 90; coverage.scan_truncated says where a bounded scan stopped).

New in 0.14.0: RHC wallet and positions answers report the on-chain check (holding_status per position, still held vs transferred, verified value) instead of presenting FIFO-open positions as current holdings; copy-trade rules are typed with operational_state.

New in 0.10.1 — RHC price-alert copy and types. RHC price alerts have been event-driven off each rhc:dex_trade since 2026-09-15 (price-table polls are the safety net), so the create response's evaluation now says mode: "event_driven" with trigger and fallback_poll_seconds; the RhcPriceAlertCreatedResponse.evaluation type accepts both "event_driven" and the legacy "polled", and the action/plugin descriptions no longer claim a ~15 s poll.

New in 0.9.0 — a real registration bug fixed, plus early buyers. An internal agentic-infra audit found getTokenTopTraders/getTokenFlow/getTokenPeakHistory/getTokenRisk/getTokenHolders were never actually broken here — but did find and fix the equivalent bug in solana-agent-kit-plugin-robinhood-chain (5 tool functions exported but never imported into the plugin object, unreachable via plugin.methods despite existing in the package). This client's own addition: getTokenEarlyBuyers (GET /rhc/tokens/{address}/early-buyers) — first buyers of a token, ranked, with still-holding status, previously unreachable from any agent surface.

New in 0.8.0 — tokenized equities + the liquidity-removals feed. Two new actions / client methods. GET_RHC_EQUITIES / client.getEquities() (GET /rhc/equities, BASIC+) lists every official Robinhood tokenized stock and ETF (NVDA, SPY, AAPL, …) with live price / MC / liquidity and 24h trades, ETH volume and buyer-seller split, sortable by volume / trades / market_cap / last_trade / symbol, filterable by exact symbol or substring q. Identity is the issuer beacon, never the name: a token is listed only if its contract is an EIP-1967 beacon proxy on Robinhood's issuer beacon 0xe10b6f6b…151b00, read from our own node — on ship day there were 20 fake "GameStop • Robinhood Token" contracts and 8 fake NVDAs with the exact official suffix, and none of them appear. GET_RHC_LP_EVENTS / client.getLpEvents() (GET /rhc/lp-events, PRO+) is the rug signal: Uniswap v2/v3 Burn and v4 ModifyLiquidity with a negative delta on tracked pools, from our node's log subscription, filterable by token / pool / provider / dex and cursor-paginated on next_before. Removals only — adds are not persisted (the response's coverage block says adds_persisted: false), amounts are raw uint256 strings, v4 rows carry liquidity only, and provider_is_token_deployer is the classic rug tell. Data since 2026-08-05.

New in 0.7.0 — holder_growth: who arrived and who left. client.getTokenHolders(address) now returns holder_growth on GET /rhc/tokens/{address}/holders: { "1h", "24h", "7d" } × { cutoff_block, entered, entered_still_holding, exited, net }. entered = addresses whose first Transfer of the token landed at-or-after the window's cutoff block (any current balance); entered_still_holding = those still non-zero; exited = pre-existing holders whose last movement in the window left them at zero; net ≈ the change in holder_count. Pools and burn addresses are excluded from every count. This exists because RHC balances are folded from ERC-20 Transfer logs on our own node — the fold keeps first-seen and last-moved blocks per address and retains zero-balance rows — so it is a direct read, not an estimate; the Solana census is a point-in-time ledger scan with no history and cannot answer this. A window is null (never 0) only when the chain had no ingested trades in it; the whole block is null only if the growth read failed. Sanity check from ship day: a token launched that morning showed 593 entered / 560 still holding over 24h, and holder_count was exactly 560.

New in 0.6.0 — wallet intelligence. Ten new operations covering the Robinhood Chain wallet surface, which had no SDK binding at all until now: six new actions — GET_RHC_WALLET, GET_RHC_WALLET_PNL, GET_RHC_WALLET_POSITIONS, GET_RHC_WALLET_TRADES, MANAGE_RHC_WALLET_TRACKER (list / add / remove / relabel in one action) and GET_RHC_WALLET_TRACKER_FEED (merged tape or per-wallet rollup). Everything is ETH-denominated, and cost basis is FIFO over a rolling 90-day window — cost_basis_observable_from names the date the window opens, so a position opened before it reads as a sell with no matching buy. The profile / PnL / positions trio shares ONE snapshot cache server-side, so calling all three on an address costs roughly one computation rather than three; cache_hit says which call paid for it. Watchlist quotas are per chain (PRO 50 / ULTRA 250 / BUSINESS 1,000 RHC wallets), independent of your Solana list.

New in 0.4.0 — the rule engine: 52 endpoints (was 30). 22 new operations let your agent create and manage server-side rules that push signals to a webhook or WebSocket: copy-trade rules (watch up to 250 source wallets, ETH-denominated sizing), price alerts (market-cap drop + optional recovery leg), KOL coordination alerts (N+ KOLs on one token in a window) and first-touch subscriptions (the first tracked-KOL buy on a token). Rules are data, never execution — a fired rule delivers a suggested size, it never places an order. Every quota is per chain: a full set of Solana rules does not consume RHC capacity.

Earlier: deployer intelligence deepened — trajectory (is this deployer improving or declining), the paginated tokens launch list, history, chain-wide stats, the alerts feed and best-tokens from reputable deployers only. Plus KOL coordination and first-touches, and two batch endpoints (50 tokens per price lookup, 20 per buyer-quality scoring) that count as one request each.

Robinhood Chain intelligence, EVM-native: track Solana KOLs' verified RHC wallets (recovered by tracing their Solana→EVM bridge deposits — a dataset unique to MadeOnSol), rank 99k+ RHC deployers by graduation/runner rate, detect same-block launch bundles and score early-buyer cohorts, and stream the Uniswap v2/v3/v4 trade tape with the effective trader EOA (tx.from, or the ERC-4337 userOp sender when bundled — never the bundler or the router). Every field is EVM-native — token_address (lowercase 0x), eth_amount, tx_hash, block_number, net_flow_eth. Same msk_ API key, same base URL, bundled into every tier at no extra cost. Get a free key at madeonsol.com/pricing.

Quick start (10 seconds)

npm install @madeonsol/plugin-robinhood-chain

import { robinhoodChainPlugin } from "@madeonsol/plugin-robinhood-chain";
const agent = {
  plugins: [robinhoodChainPlugin],
  settings: { ROBINHOOD_CHAIN_API_KEY: "msk_..." }, // free key at https://madeonsol.com/pricing
};
// Then ask the agent: "What are KOLs buying on Robinhood Chain right now?"

Authentication

This plugin is key-mode only — a single MadeOnSol API key (msk_, Bearer). Robinhood Chain does have a keyless x402 pay-per-call rail (a narrow keyless subset, listed live at /api/x402/rhc, dual-accept USDG-on-RHC or USDC-on-Solana — see madeonsol.com/robinhood/x402), but it is not wired into this plugin.

Setting	Notes
ROBINHOOD_CHAIN_API_KEY	Your msk_ key. Get a free one — the same key already covers the Solana API.
MADEONSOL_API_KEY	Fallback — used if ROBINHOOD_CHAIN_API_KEY is unset.
ROBINHOOD_CHAIN_API_URL	Optional base URL. Default https://madeonsol.com.

What it does

Gives your ElizaOS agent access to MadeOnSol's Robinhood Chain intelligence API. Every action maps to one real /rhc/* endpoint.

Action	Endpoint	Tier
GET_RHC_KOL_FEED	GET /rhc/kol/feed	BASIC+
GET_RHC_KOL_LEADERBOARD	GET /rhc/kol/leaderboard	BASIC+
GET_RHC_KOL_HOT_TOKENS	GET /rhc/kol/hot-tokens	BASIC+
GET_RHC_KOL_PROFILE	GET /rhc/kol/{wallet}	BASIC+
GET_RHC_KOL_COORDINATION	GET /rhc/kol/coordination	BASIC+
GET_RHC_KOL_FIRST_TOUCHES	GET /rhc/kol/first-touches	BASIC+
GET_RHC_KOL_SCOUTS	GET /rhc/kol/scouts/leaderboard	PRO+
GET_RHC_TRADES	GET /rhc/trades	PRO+
GET_RHC_LP_EVENTS	GET /rhc/lp-events — liquidity removals only (rug signal)	PRO+
GET_RHC_TOKENS	GET /rhc/tokens	PRO+
GET_RHC_EQUITIES	GET /rhc/equities — beacon-verified tokenized stocks/ETFs	BASIC+
GET_RHC_TOKEN	GET /rhc/tokens/{address}	BASIC+
GET_RHC_TOKEN_BATCH	POST /rhc/token/batch (max 50)	BASIC+
GET_RHC_TOKEN_CANDLES	GET /rhc/tokens/{address}/candles	PRO+
GET_RHC_KOL_CONSENSUS	GET /rhc/tokens/{address}/kol-consensus	PRO+
GET_RHC_BUYER_QUALITY	GET /rhc/tokens/{address}/buyer-quality	BASIC+
GET_RHC_TOKEN_BATCH_BUYER_QUALITY	POST /rhc/tokens/batch/buyer-quality (max 20)	BASIC+
GET_RHC_TOKEN_BUNDLE	GET /rhc/tokens/{address}/bundle	BASIC+
GET_RHC_TOKEN_BUNDLES	GET /rhc/tokens/{address}/bundles — every buy cluster, launch and later	PRO+
GET_RHC_TOKEN_BUNDLE_SHARE	GET /rhc/tokens/{address}/bundle-share — null with a reason unless every wallet was read	PRO+
GET_RHC_TOKEN_KOL_TRADES	GET /rhc/tokens/{address}/kol-trades (include_balances PRO+)	BASIC+
GET_RHC_DEPLOYER_LEADERBOARD	GET /rhc/deployer-hunter/leaderboard	BASIC+
GET_RHC_DEPLOYER_PROFILE	GET /rhc/deployer-hunter/{address}	BASIC+
GET_RHC_DEPLOYER_TRAJECTORY	GET /rhc/deployer-hunter/{address}/trajectory	BASIC+
GET_RHC_DEPLOYER_TOKENS	GET /rhc/deployer-hunter/{address}/tokens	BASIC+
GET_RHC_DEPLOYER_HISTORY	GET /rhc/deployer-hunter/{address}/history	PRO+
GET_RHC_DEPLOYER_ACTIVITY	GET /rhc/deployer-hunter/{address}/activity	PRO+
GET_RHC_DEPLOYER_BEST_TOKENS	GET /rhc/deployer-hunter/best-tokens	BASIC+
GET_RHC_DEPLOYER_STATS	GET /rhc/deployer-hunter/stats	BASIC+
GET_RHC_DEPLOYER_ALERTS	GET /rhc/deployer-hunter/alerts	BASIC+
GET_RHC_RECENT_BONDS	GET /rhc/deployer-hunter/recent-bonds	BASIC+
GET_RHC_ALPHA_WALLETS	GET /rhc/alpha-wallets	PRO+

Rule engine

Rules are data, not execution — a fired rule delivers a signal (webhook and/or WebSocket) with a suggested size; nothing is ever traded on your behalf. Every quota below is per chain, so Solana rules do not eat into your RHC allowance.

The four MANAGE_* actions list your rules by default, and pause / resume / delete only when the message names an explicit rule id (numeric for copy-trade and price alerts, a UUID for coordination alerts and first-touch subscriptions). Creating a rule takes a webhook URL and returns a one-time webhook_secret, so it lives on the typed client rather than on a natural-language action.

Action	Endpoints	Tier
MANAGE_RHC_COPYTRADE_RULES	GET|POST /rhc/copytrade/subscriptions, GET|PATCH|DELETE /rhc/copytrade/subscriptions/{id}	PRO+
GET_RHC_COPYTRADE_SIGNALS	GET /rhc/copytrade/signals	PRO+
MANAGE_RHC_PRICE_ALERTS	GET|POST /rhc/price-alerts, GET|PATCH|DELETE /rhc/price-alerts/{id}	PRO+
GET_RHC_PRICE_ALERT_EVENTS	GET /rhc/price-alerts/events	PRO+
MANAGE_RHC_COORDINATION_ALERTS	GET|POST /rhc/kol/coordination/alerts, GET|PATCH|DELETE /rhc/kol/coordination/alerts/{id}	PRO+
MANAGE_RHC_FIRST_TOUCH_SUBSCRIPTIONS	GET|POST /rhc/kol/first-touches/subscriptions, GET|PATCH|DELETE /rhc/kol/first-touches/subscriptions/{id}	ULTRA+

Three RHC-specific behaviours worth knowing before you build on these:

• Price alerts are event-driven, but not sub-second. Since 2026-09-15 they are evaluated as trades land on the rhc:dex_trade feed, with a price-table poll (5 s while the feed is degraded, 60 s otherwise) and a trade-tape replay as safety nets. Latency is a few seconds (the chain trade flush is ~2 s). The Solana price alerts fire sub-second; assuming parity will mis-size a strategy. Alerts also expire 30 days after creation, and token_address / drop_pct / recovery_pct are immutable (delete and recreate to change a threshold).
• RHC copy-trade has no market-cap band. The producer's event carries no market cap, so a min_mc_usd / max_mc_usd filter could only be a per-event lookup in the hot path of a ~3.3M trades/day chain. It is omitted rather than shipped as a filter that silently never matches. Amounts are ETH (min_trade_eth, sizing_amount), not SOL.
• Coordination scores: quality is real, earliness is defaulted. The v1 scorer is shared with Solana so the number is comparable, but RHC has no early-entry equivalent, so that component is defaulted to 50 while quality uses the real KOL 7-day win rate. Each fired signal records which components were real in score_inputs. Likewise, first-touch filters offer min_kol_winrate and strategy instead of Solana's min_scout_tier / min_n_touches — RHC has no scout score, and a filter that silently matched nothing would be worse than its absence.

Usage

import { robinhoodChainPlugin } from "@madeonsol/plugin-robinhood-chain";

const agent = {
  plugins: [robinhoodChainPlugin],
  settings: {
    ROBINHOOD_CHAIN_API_KEY: "msk_your_api_key_here", // free at madeonsol.com/pricing
  },
};

Your agent can then answer queries like:

• "What are KOLs buying on Robinhood Chain right now?"
• "Show the RHC KOL leaderboard this week"
• "Which Robinhood Chain tokens are 2+ KOLs buying in the last hour?"
• "Is there a launch bundle on 0x…?"
• "Score the early buyers on 0x…"
• "Top Robinhood Chain deployers by graduation rate"
• "Is Robinhood Chain deployer 0x… improving or declining?"
• "List every token deployer 0x… has launched on Robinhood Chain"
• "What just graduated on Robinhood Chain?"
• "Show the latest RHC deployer alerts from elite deployers"
• "Which Robinhood Chain tokens have 3+ KOLs coordinating right now?"
• "Show smart-money wallets on Robinhood Chain"
• "List my Robinhood Chain copy-trade rules"
• "Pause RHC copy-trade rule 12"
• "What have my Robinhood Chain copy-trade rules fired lately?"
• "Show my RHC price alerts"
• "Which of my Robinhood Chain price alerts dipped this week?"
• "List my RHC KOL coordination alert rules"
• "Show my Robinhood Chain first-touch subscriptions"

Programmatic client

Every endpoint is also on a typed client — call it directly from a custom action:

import { RobinhoodChainClient } from "@madeonsol/plugin-robinhood-chain";

const client = new RobinhoodChainClient({ apiKey: process.env.ROBINHOOD_CHAIN_API_KEY });

// Live KOL feed — EVM-native (eth_amount, token_address, tx_hash, block_number)
const { data } = await client.getKolFeed({ limit: 10, action: "buy" });
for (const t of data.trades) {
  console.log(`${t.kol_name} ${t.action} ${t.token_symbol} for ${t.eth_amount} ETH (${t.launchpad})`);
}

// Same-block launch-bundle detection (no atomic_tx on this Arbitrum Orbit L2)
const bundle = await client.getTokenBundle("0x1234567890abcdef1234567890abcdef12345678");
// bundle.data.bundle → { wallet_count, bundle_kind: "same_block" | "none", held_pct_of_supply, ... }

// KOL consensus — net_flow_eth denominated
const consensus = await client.getTokenKolConsensus("0x1234567890abcdef1234567890abcdef12345678");

// Is this deployer improving? (success = $40K+ peak MC, not a bonding curve)
const traj = await client.getDeployerTrajectory("0x1234567890abcdef1234567890abcdef12345678");
// traj.data.trajectory → { trend: "improving" | "declining" | "stable", current_streak, rolling_bond_rates, ... }

// Deployer alert feed — tradability-filtered by default (liquidity_usd >= $100)
const alerts = await client.getDeployerAlerts({ deployer_tier: "elite", limit: 50 });
// each alert: tier (resolved NOW) + tier_at_alert (snapshot) + tier_is_stale
// pass { include_untradeable: true } for the raw tape

// Batch: up to 50 tokens priced in ONE request (counts as one call)
const batch = await client.getTokenBatch(["0x1234…", "0xabcd…"]);
// unknown addresses come back as { address, found: false } — the array stays positional

// Batch buyer-quality — MAX 20 addresses, not 50 (per-token cohort computation)
const scores = await client.getTokenBatchBuyerQuality(["0x1234…", "0xabcd…"]);

// Tokenized equities — identity is the issuer BEACON, never the name (BASIC+)
const eq = await client.getEquities({ sort: "volume", limit: 20 });
const nvda = await client.getEquities({ symbol: "NVDA" });
// eq.data.equities[i] → { symbol, name, token_address, issuer_beacon, price_usd, market_cap_usd,
//                         liquidity_usd, trades_24h, volume_eth_24h, buyers_24h, sellers_24h, ... }

// Liquidity REMOVALS — the rug signal (PRO+). Removals only; adds are not persisted.
const lp = await client.getLpEvents({ token: "0x1234567890abcdef1234567890abcdef12345678", limit: 50 });
// lp.data.events[i] → { event: "remove", dex, provider, provider_is_token_deployer, liquidity,
//                       amount0, amount1, token_amount_raw, quote_amount_raw (raw uint256 STRINGS), ... }
// lp.data.coverage.adds_persisted === false; page with { before: lp.data.next_before }

Rule engine (writes)

// Copy-trade rule — ETH-denominated, no market-cap band on RHC.
// The rule delivers a SUGGESTED size; it never places an order.
const rule = await client.createCopytradeSubscription({
  name: "elite RHC wallets",
  source_wallets: ["0x1234…", "0xabcd…"], // lowercased server-side; any valid 0x wallet, KOL or not (since 2026-10-04):
                                          // see rule.data.subscription.source_admission + operational_state
  min_trade_eth: 0.05,
  only_action: "buy",
  sizing_mode: "proportional",
  sizing_amount: 0.25,
  delivery_mode: "webhook",
  webhook_url: "https://your-app.example/rhc-copytrade",
});
// rule.data.webhook_secret is shown ONCE — store it. Payloads are signed
// Lowercase hex HMAC-SHA256 (no prefix) over `<timestamp>.<rawBody>` in
// X-MadeOnSol-Signature; <timestamp> = X-MadeOnSol-Timestamp, unix MILLISECONDS;
// key = the webhook_secret string exactly as returned (do not hex-decode it).

// Catch-up after a missed webhook (7-day retention)
const signals = await client.getCopytradeSignals({ subscription_id: rule.data!.subscription.id });

// Price alert — market-cap denominated, baseline captured NOW.
// Event-driven off each RHC trade (a few seconds), not sub-second like the Solana alerts.
const alert = await client.createPriceAlert({
  token_address: "0x1234567890abcdef1234567890abcdef12345678",
  drop_pct: 30,
  recovery_pct: 15, // optional second leg, measured off the dip low
  delivery_mode: "websocket",
});
// alert.data.evaluation → { mode: "event_driven", trigger: "rhc:dex_trade", interval_seconds: 5, fallback_poll_seconds: { fast: 5, slow: 60 }, note }

// Dip / recovery history (30-day retention)
const events = await client.getPriceAlertEvents({ event_type: "dip", limit: 100 });

// Coordination alert rule — quality is real, earliness is defaulted on RHC
const coord = await client.createCoordinationAlert({ min_kols: 4, window_minutes: 15, min_score: 60 });

// First-touch subscription (ULTRA+) — filters is a whole-object REPLACE on update
const ft = await client.createFirstTouchSubscription({
  filters: { min_first_buy_eth: 0.1, min_kol_winrate: 0.55, strategy: "swing" },
});

// Pause / resume / delete
await client.updateCopytradeSubscription(rule.data!.subscription.id, { is_active: false });
await client.deletePriceAlert(alert.data!.alert.id);
await client.deleteFirstTouchSubscription(ft.data!.subscription.id); // UUID

Every request populates client.lastRateLimit (limit / remaining / reset / requestId).

Why Robinhood Chain

Robinhood Chain is an Arbitrum Orbit L2 (chain id 4663). Two things follow from that, and this plugin models both honestly:

• No atomic multi-signer transaction → the bundle detector reports same_block (3+ first buys in one block) or none; there is no atomic_tx kind.
• Direct-to-DEX launchpads (most RHC launchpads have no bonding curve) → "graduation" is a market-cap milestone: graduation_rate = share of a deployer's tokens that reached a $40K+ peak MC; runner_rate = share that reached $100K+.
• Tiers ride runner_rate, not graduation_rate → elite = 5+ tokens, 24h+ of deployer history, runner_rate >= 0.50; good = same with >= 0.25. graduation_rate is still returned and still means the $40K bar, but it no longer sets the tier (it proved farmable by operators rotating wallets); only spammer still keys off it (20+ tokens, graduation_rate < 0.05).

Tiers

Tier	Price	Requests/day
BASIC (free)	$0	200
PRO	€43/mo (€430/yr) ≈ $49	10,000
ULTRA	€131/mo (€1310/yr) ≈ $149	100,000
BUSINESS	€400/mo (€4000/yr) ≈ $449	500,000

Robinhood Chain coverage is bundled into every tier at no extra cost. BASIC endpoints work with any valid key; GET /rhc/trades, GET /rhc/tokens, GET /rhc/tokens/{address}/candles, GET /rhc/tokens/{address}/kol-consensus, GET /rhc/deployer-hunter/{address}/history, GET /rhc/alpha-wallets, and the whole rule engine except first touches (copy-trade rules + signals, price alerts + events, coordination alerts) require PRO+. First-touch subscriptions require ULTRA+. Rule-engine quotas — how many rules, and how many source wallets per copy-trade rule — scale with tier and are counted per chain. ULTRA also unlocks the deepest read fields (the full bundle cohort with wallet identity, the KOL-consensus buyers/exited lists, first_kol.evm_address on first-touches, and the full 500-alert page on the deployer alert feed — BASIC/PRO cap at 50). Get a key at madeonsol.com/pricing.

Also Available

Platform	Package
Solana Agent Kit	solana-agent-kit-plugin-robinhood-chain
TypeScript SDK	robinhood-chain-sdk on npm
Python SDK	robinhood-chain on PyPI
Rust SDK	robinhood-chain on crates.io
MCP Server (Claude, Cursor)	mcp-server-robinhood-chain

Links

• Robinhood Chain product → https://madeonsol.com/robinhood
• API docs → https://madeonsol.com/api-docs
• Pricing & free API key → https://madeonsol.com/pricing

License

MIT

---

Agent Intelligence Gateway compatibility (coordinated release)

Scope: ElizaOS Robinhood Chain plugin — Robinhood Chain.

MadeOnSol's Agent Intelligence Gateway is a separate six-action, read-only research layer: discover_opportunities, evaluate_token, inspect_wallet, inspect_deployer, evaluate_signal, and changes_since. These actions must not be inferred from a package's existing endpoint tools or release number. Follow only an actually published package manifest and the six-tool reference.

The plugin's current keyed RHC actions are independent of the upcoming six-action gateway. On a future release, implement only actually supported chain capabilities: tracked KOL/deployer discovery and EVM-native token/wallet evidence are available sources; Solana Signal Scorecard and near-bonded launchpad parity must NOT be advertised as native RHC tools.

Access models: a paid subscription authenticates a recurring API client; individual x402 calls are available only for exact live priced routes and accepted payment legs. MCP/Agent Kit/ElizaOS are tool integration layers, not independent billing plans. An account's usage limits and commercial redistribution entitlements still apply.

The coordinated release is tracked in the MadeOnSol source repository. Do not claim six-tool support from an unpublished local manifest or call a not-yet-deployed public Agent Gateway route. Client packages must be published and their registry versions synchronized before the site advertises support.