# Otto Data — Robinhood Chain MCP server

Live Robinhood Chain tokenized-stock data: basis vs NASDAQ, gaps, pools, whale flows.

## Links
- Registry page: https://www.getdrio.com/mcp/app-ottodata-otto
- Repository: https://github.com/Degergokalp/otto-data
- Website: https://ottodata.app

## Install
- Endpoint: https://api.ottodata.app/mcp
- Auth: Not captured

## Setup notes
- Remote endpoint: https://api.ottodata.app/mcp

## Tools
- hood_basis_snapshot - Current basis (premium/discount) snapshot for all Robinhood Chain
    tokenized stocks. Per ticker: chainlink_px (on-chain price), ref_last
    (NASDAQ), basis_bps (+ = token trades at a premium), overnight_bps (move
    vs last close) and the oracle_paused flag. Endpoint: https://api.ottodata.app/mcp
- hood_basis_history - Minute-level basis history for one ticker (newest first). Example
    tickers: NVDA, TSLA, SPY. limit max 5000. Endpoint: https://api.ottodata.app/mcp
- hood_gaps_summary - Overnight and weekend premium/discount statistics for all tickers:
    average, min/max and latest value (bps). Tokens trade 24/5, so this
    measures the drift that builds up while NASDAQ is closed. Endpoint: https://api.ottodata.app/mcp
- hood_gaps_live - Live view of the current off-hours session: which tickers trade at the
    largest premium/discount vs their last close. Returns 'regular' when the
    stock market is open. Endpoint: https://api.ottodata.app/mcp
- hood_gap_sessions - Session-by-session gap history for one ticker (each overnight/weekend
    session is a separate row). Endpoint: https://api.ottodata.app/mcp
- hood_feeds - Registry of all tokenized stock and crypto feeds tracked on Robinhood
    Chain (Chainlink proxy + token contract addresses). Endpoint: https://api.ottodata.app/mcp
- reddit_alpha_signals - Ticker alpha signals extracted from Reddit (novelty, mention velocity
    and cross-sub spread components). signal_type: ticker_alpha|crowded_trade|
    event_mispricing|squeeze_watch. tickers is comma-separated (NVDA,TSLA). Endpoint: https://api.ottodata.app/mcp
- reddit_market_regime - Current market regime inferred from Reddit chatter (e.g.
    mag7_only_rally, risk_on_call_chase) + confidence + flags to watch. Endpoint: https://api.ottodata.app/mcp
- hood_attention - Reddit attention/alpha score joined with live basis for Hood tokenized
    stocks: which tokens have social interest AND an on-chain premium/discount
    at the same time. Fan-out (same post, many tickers) is deduplicated. Endpoint: https://api.ottodata.app/mcp
- hood_pools - Tracked Uniswap (Hood) pools: pool price per token, liquidity (USD) and
    deviation vs the Chainlink oracle price (dev_bps). Refreshed every 5 min. Endpoint: https://api.ottodata.app/mcp
- oracle_deviation - Chainlink-vs-Uniswap pool price deviation (bps, sorted by absolute
    value). status: ok (<100), warning (100-500), alert (>500). Large
    deviations are normal in low-liquidity pools — check liquidity_usd. Endpoint: https://api.ottodata.app/mcp
- stable_risk - Deviation of USDG and other stablecoins from $1 parity (depeg risk, bps). Endpoint: https://api.ottodata.app/mcp
- market_events - Machine-readable news events (crypto + stocks). symbols is
    comma-separated (NVDA,BTC), event_type: listing|hack|regulation|earnings|
    etf|partnership|macro|liquidation|stablecoin|general. importance 0-100. Endpoint: https://api.ottodata.app/mcp
- token_flows - Large on-chain token transfers (whale flows): 32 stock tokens + USDG
    above the USD threshold. direction: mint|burn|transfer. Mints/burns show
    the tokenized stock supply changing (issuance/redemption). Endpoint: https://api.ottodata.app/mcp
- flow_summary - Whale-flow summary per ticker: transfer count, total USD volume,
    mint/burn USD (supply change) and the largest transfer. Endpoint: https://api.ottodata.app/mcp
- hood_stock_research - Daily deep-research report: score (0-100), rating (strong_buy|buy|hold|
    avoid) and 4 analysis columns per Hood tokenized stock: thesis, dated
    catalysts (off_hours-flagged, verified earnings dates), financials (PE
    ttm/fwd, growth, margins, valuation_label: expensive|fair|discount|n_a),
    competitors (peers + positioning) and news_summary ([+]/[=]/[-] tagged).
    The api_data field carries exact API numbers (price, market cap, 1d/7d/30d,
    52w, target mean/hi/lo, analyst rec counts) — use it when precision
    matters. With ticker: one card + live basis join; empty: full report. Endpoint: https://api.ottodata.app/mcp
- hood_off_hours_catalysts - Dated catalysts that can move token prices while NASDAQ is closed
    (nights/weekends) — flattened from all research cards, sorted by date.
    For agents watching overnight gap and weekend risk. Endpoint: https://api.ottodata.app/mcp
- hood_earnings_risk - Earnings risk for Hood tokenized stocks (weekly earnings radar): per
    ticker report_date/time, days_to_earnings, implied_move_pct (option-implied
    expected move), beat_probability (0-100), PEAD status + live basis join.
    Earnings released while NASDAQ is closed make the token gap — watch small
    days_to_earnings for off-hours risk management. tickers: CSV filter
    (empty = full Hood universe). Endpoint: https://api.ottodata.app/mcp
- hood_sector_rotation - Sector rotation context for Hood tokenized stocks (API-only tracker
    refreshed every 3h): market regime (risk_on|risk_off|mixed), an 11-SPDR
    sector score/label/flow board and a per-ticker join — sector score
    (0-100), label (inflow|interest|neutral|outflow_leaning|outflow), flow
    trend, theme matches + live basis. Answers where money is rotating and
    whether your token's sector is in inflow or outflow. tickers: CSV filter
    (empty = full Hood universe). Endpoint: https://api.ottodata.app/mcp
- service_status - Trust status of the Otto data layer: per-feed freshness (age_sec/stale),
    24h tick coverage, NASDAQ reference availability and oracle-pause count.
    Call before making trading decisions — status: ok|degraded|down. Endpoint: https://api.ottodata.app/mcp
- chain_stats - Robinhood Chain deployment statistics: daily deploy/token counts, top
    deployers, total contract/verified counts (Ottoscan analytics). Endpoint: https://api.ottodata.app/mcp
- chain_deployments - New contract deployments on Robinhood Chain (Ottoscan; full history
    since genesis). tokens_only=True returns only new token contracts. Endpoint: https://api.ottodata.app/mcp
- gap_trade_signals - Deterministic signals for the gap-trader strategy: per Hood ticker the
    overnight gap it currently carries (bps), a signal (long_at_open |
    avoid_or_reduce | none), 14-day gap statistics, the hit rate of pre-open
    gap direction vs open direction (hit_rate_14d) and risk flags
    (oracle_paused, stale, low_liquidity, earnings_within_48h). Signals are
    NOT orders — sizing and approval belong to the user. The most informative
    window is pre-open 09:15-09:29 ET; signals are suppressed while the market
    is open (session=regular). Endpoint: https://api.ottodata.app/mcp
- perp_funding - Hourly funding rates on tokenized-stock perps (Arcus + Lighter). Without
    params: latest value per venue+ticker pair (funding_apr_pct = annualized
    %). With ticker: history. Tokens trade 24/7 while the stock market does
    not — weekend/overnight funding is the price of that mismatch. Endpoint: https://api.ottodata.app/mcp
- perp_spot_basis - Perp mark price vs Hood on-chain spot (Chainlink per-share + pool),
    deviation in bps per ticker. A large |perp_vs_chainlink_bps| means the
    perp and spot price the same stock differently — a cross-venue opportunity
    or a stale-oracle signal. Fields are null for markets without a Hood spot. Endpoint: https://api.ottodata.app/mcp
- funding_carry_signals - Deterministic funding-carry candidates joining perp funding
    (Arcus/Lighter) with perp-vs-spot basis. Per ticker: funding rate +
    annualized funding_apr_pct, perp-vs-Chainlink gap (bps) and a label —
    carry_long_spot_short_perp (hold Hood spot, short the perp, collect
    positive funding), carry_short_spot_long_perp (inverse) or no_carry —
    plus the standard risk flags. min_abs_bps filters on
    |perp_vs_chainlink_bps|. Signals are NOT orders. Endpoint: https://api.ottodata.app/mcp
- narrative_trade_signals - Deterministic candidates for the narrative-trader strategy: per Hood
    ticker the highest-alpha Reddit signal (alpha_score, evidence, themes), a
    signal bias (long_candidate = rising attention | avoid_or_fade = crowded
    trade | context = regime info), live Chainlink price, basis and risk
    flags. The `reason` field is the Reddit summary — carry it into status
    reports and the chart as the buy/sell rationale. Signals are NOT orders. Endpoint: https://api.ottodata.app/mcp
- hood_quote - Minimal fast quote for one Hood ticker: Chainlink price (token +
    per-share), NASDAQ references (ref_last, ref_prev_close), basis/overnight
    bps, the most liquid pool's price/liquidity/deviation and
    oracle_paused/stale flags. Use for sizing and fill pricing instead of
    pulling the full 32-ticker snapshot. Endpoint: https://api.ottodata.app/mcp
- hood_ticker_brief - One-call brief for a single Hood ticker: live quote (price, basis,
    pool, risk flags), research card (rating/score/thesis/catalysts), earnings
    risk, sector rotation context, best Reddit attention signal, 24h
    whale-flow summary and recent tagged news. Replaces 6-7 separate tool
    calls when an agent researches one ticker. Missing upstream sources
    fail-soft: the field is null. Endpoint: https://api.ottodata.app/mcp
- agent_position_book - Server-side derived open position book for a trading agent:
    every order_filled event without a later matching position_closed on the
    same ticker counts as open, joined with the live Chainlink price for
    unrealized P&L (bps and USD). Replaces rebuilding the book from raw
    agent events. agent: gap-trader | narrative-trader.
    mode: '' (all) | paper | live | onchain — filter positions by execution mode. Endpoint: https://api.ottodata.app/mcp
- agent_performance - Realized trading performance for an agent, derived from
    position_closed events: trade count, win rate, total/average P&L (bps),
    total P&L (USD), average holding hours, per-ticker breakdown and the last
    20 closed trades. agent: gap-trader | narrative-trader.
    mode: '' (all) | paper | live | onchain — filter trades by execution mode. Endpoint: https://api.ottodata.app/mcp
- report_agent_status - Status report from a trading agent — the live panel on
    ottodata.app/agents renders this stream. kind: run_started | signals |
    order_proposed | order_approved | order_filled | order_skipped |
    position_closed | run_summary | error. agent: gap-trader |
    narrative-trader. key: the operator's OTTO_AGENT_KEY value (wrong keys are
    rejected). Call at every runbook step; keep message short and
    human-readable (e.g. 'BUY 3 NVDA @ 184.20 limit — gap +82bps'). Endpoint: https://api.ottodata.app/mcp
- execute_onchain_swap - Execute a REAL on-chain swap on Robinhood Chain via the Rialto router,
    signed by Otto's server-side trading wallet. side=buy spends `usd_amount`
    USDG to buy the ticker's Hood token; side=sell sells `qty` tokens back to
    USDG. The server enforces hard guardrails independently of the caller:
    USDG<->allowlisted-token pairs only, per-trade and daily USD caps, and a
    slippage cap. On success the matching order_filled/position_closed event
    (payload mode=onchain, with tx_hash) is written automatically — the
    position book, performance stats and trade chart update without a
    separate report_agent_status call. key: the operator's OTTO_AGENT_KEY.
    agent: gap-trader | narrative-trader. Returns tx_hash, fill qty/price/usd
    and pnl_bps (sells with a known entry). Endpoint: https://api.ottodata.app/mcp
- competition_paper_trade - Place a PAPER fill in Otto's trading competition on behalf of the
    key's owner. No real funds move — the fill is priced server-side at the
    latest Chainlink price (callers can never supply a price). api_key: the
    personal otto_pk_ key issued when the wallet joined at
    ottodata.app/competition. side: buy | sell. qty: token quantity (shares).
    Include a short `reason` — it shows up in the owner's trade history.
    Rules enforced server-side: $10,000 starting budget, long-only, max
    $2,000 notional per trade, max 10 open positions, max 40 trades/day.
    On a rule violation the response is {"error": "..."} — read it and
    adjust instead of retrying blindly. Endpoint: https://api.ottodata.app/mcp
- competition_my_portfolio - The competition paper portfolio behind an otto_pk_ key: cash, equity,
    return %, realized/unrealized P&L, open positions with live prices,
    recent trades (each tagged with its source: your MCP agent or Otto's
    hosted gap/narrative engine) and the entry's strategy prefs. Check this
    before sizing a new competition_paper_trade. Endpoint: https://api.ottodata.app/mcp
- competition_leaderboard - Public leaderboard of Otto's paper trading competition: every
    participant ranked by return % on the shared $10,000 starting budget,
    with equity, P&L, open position count, trade count and last activity.
    No key required. Fills are server-priced from Chainlink, so rankings
    cannot be gamed with self-reported prices. Endpoint: https://api.ottodata.app/mcp
- partner_swap_quote - Get an UNSIGNED Rialto swap quote for an approved partner. YOU sign
    and broadcast the returned transaction yourself, with your own wallet's
    private key, on your own infrastructure — Otto never sees or holds your
    key and never submits anything on your behalf. api_key: the otto_pn_
    key Otto's admin issued you directly. sell_token/buy_token: Hood token
    contract addresses (0x...). sell_amount: human units of sell_token (e.g.
    "25" USDG, not wei). taker: the wallet address that will actually sign
    and hold the position. Returns the raw Rialto quote including tx.to,
    tx.data, tx.value and min_buy_amount — everything needed to build and
    sign the transaction. After broadcasting, call partner_report_fill so
    the trade shows up in Otto's records. Endpoint: https://api.ottodata.app/mcp
- partner_report_fill - Report a fill you already signed and broadcast yourself (via
    partner_swap_quote) so it appears in Otto's records. Otto does NOT
    verify the transaction on-chain in this version — it trusts the
    partner it already approved. side: buy | sell. tx_hash: the
    transaction hash from your own broadcast. Endpoint: https://api.ottodata.app/mcp
- partner_my_trades - Recent fills you've reported with partner_report_fill, most recent
    first. Endpoint: https://api.ottodata.app/mcp

## Resources
Not captured

## Prompts
- gap_trader_playbook - Gap Trader Playbook Full runbook for the gap-trader paper agent: Otto gap signals +
    simulated fills, step-by-step loop with status reporting.
- narrative_trader_playbook - Narrative Trader Playbook Full runbook for the narrative-trader paper agent: Reddit narrative
    signals + simulated fills, step-by-step loop with status reporting.

## Metadata
- Owner: app.ottodata
- Version: 0.2.0
- Runtime: Streamable Http
- Transports: HTTP
- License: Not captured
- Language: Not captured
- Stars: Not captured
- Updated: Jul 16, 2026
- Source: https://registry.modelcontextprotocol.io