How to Integrate Retool with Robinhood API

Before configuring any Retool integration with Robinhood's unofficial API, you must understand the significant risks involved: 1. Terms of Service violation: Robinhood's ToS explicitly prohibits automated access, scraping, or using the API for purposes other than the Robinhood app itself. Using these endpoints for your own tooling violates these terms and can result in account suspension or termination. 2. No stability guarantees: Robinhood frequently updates its mobile apps and the underlying API endpoints without any announcement. A query that works today may return 404 or 401 errors tomorrow after an app update. 3. No support: There is no documentation, no developer support, and no error codes specification. You're reverse-engineering a private API. 4. Security concerns: Obtaining and storing Robinhood login credentials to generate a session token creates additional attack surface — your financial account credentials would be stored in your infrastructure. 5. MFA complications: Robinhood enforces multi-factor authentication for most accounts. Automated login flows need to handle MFA challenges (SMS or authenticator app), which is complex and fragile. With these risks understood, here is how the unofficial API works for personal dashboard use only: Robinhood's base URL is https://api.robinhood.com. Authentication uses an OAuth2-like token obtained from the /oauth2/token/ endpoint. Once authenticated, session tokens typically last 24 hours before requiring refresh. The recommended production alternative is Plaid (https://plaid.com) — Plaid's Investment API provides official, documented access to Robinhood account data along with 15,000+ other financial institutions.

If you choose to proceed with the unofficial API for personal use, you need to obtain a session token. Robinhood's login endpoint is POST /oauth2/token/ with the base URL https://api.robinhood.com. The request body requires: - username: your Robinhood email - password: your Robinhood password - grant_type: password - client_id: c82SH0WZOsabOXGP2sxqcj34FxkvfnWRZBKlBjFS (this is Robinhood's own app client ID, reverse-engineered) - scope: internal - device_token: a random UUID string - expires_in: 86400 (24 hours in seconds) If your account has MFA enabled (which it likely does), the first login attempt will return a 400 with a challenge_type field. You'll need to make a second request to /challenge/{challenge_id}/respond/ with your MFA code, then retry the token request with the challenge_id included. IMPORTANT: Do not store your Robinhood username and password in Retool. Obtain the session token manually using a tool like curl or Postman, then store only the resulting access_token in Retool Configuration Variables. Re-generate the token manually when it expires. Note: Token lifetime is typically 24 hours. Refresh tokens are provided but their refresh endpoint also requires MFA in some cases.

1// Example login request (do this manually in Postman or curl - NOT from Retool)
2// POST https://api.robinhood.com/oauth2/token/
3{
4  "username": "your_email@example.com",
5  "password": "your_password",
6  "grant_type": "password",
7  "client_id": "c82SH0WZOsabOXGP2sxqcj34FxkvfnWRZBKlBjFS",
8  "scope": "internal",
9  "device_token": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
10  "expires_in": 86400
11}
12// Response includes: access_token, refresh_token, token_type: 'Bearer'

In Retool, navigate to the Resources tab and click Add Resource. Select REST API. Name: Robinhood API Base URL: https://api.robinhood.com Authentication Headers: - Authorization: Bearer {{ retoolContext.configVars.ROBINHOOD_TOKEN }} - Accept: application/json First, store your token in a Configuration Variable: go to Settings → Configuration Variables, create ROBINHOOD_TOKEN with your access token value, and mark it as a secret. Click Create Resource. Test immediately with a GET to /user/ — if you get a 200 with your user profile, the token is valid. If you get 401, the token has expired and you need to re-authenticate manually. Note on Retool's server-side proxy: All Robinhood API calls will appear to originate from Retool's server IP addresses (for Cloud deployments). Robinhood may flag unusual access patterns from server IP ranges as suspicious and lock your account. This is another reason to use this only for personal dashboard viewing, not automated trading or high-frequency polling. Set a query refresh interval no faster than every 5 minutes to avoid triggering Robinhood's rate limiting on the server IP range.

With the resource configured, create queries to fetch portfolio and position data. The key endpoints for a portfolio dashboard are: Portfolio value: GET /portfolios/ — returns total equity, extended hours equity, and market value. The response is a list (even for single accounts) — use data.results[0] to get your portfolio. Positions: GET /positions/?nonzero=true — returns all current positions with ticker URLs, quantity, average buy price, and created_at. Note that Robinhood returns instrument URLs rather than ticker symbols — you need to make a second request to each instrument URL to get the symbol. Instrument lookup: GET /instruments/{id}/ — returns ticker symbol, name, and exchange. To avoid N+1 requests, collect all unique instrument URLs from positions and batch-resolve them. Orders: GET /orders/ — returns order history sorted by created_at descending. Supports filtering with status=filled for completed trades. Watchlist: GET /watchlists/Default/securities/ — returns your watchlisted securities. Quote data: GET /quotes/{symbol}/ — returns current price, bid/ask, and day change for a given ticker symbol. Create a getPositions query returning positions with resolved ticker symbols, and a transformer that calculates unrealized gain/loss using current price from the quote endpoint.

1// Transformer for positions with gain/loss calculation
2// Assumes positions data is in data.results
3const positions = (data.results || []).filter(p => parseFloat(p.quantity) > 0);
4
5// Note: In a real implementation, you'd need to join with quote data
6// for current prices. This transformer assumes quote data was merged separately.
7return positions.map(pos => ({
8  instrument_url: pos.instrument,
9  instrument_id: pos.instrument.split('/').filter(Boolean).pop(),
10  quantity: parseFloat(pos.quantity),
11  average_cost: parseFloat(pos.average_buy_price),
12  total_cost: parseFloat(pos.quantity) * parseFloat(pos.average_buy_price),
13  created_at: new Date(pos.created_at).toLocaleDateString(),
14  updated_at: new Date(pos.updated_at).toLocaleDateString()
15}));

Plaid's Investment Holdings API is the officially supported, Terms-of-Service compliant way to access Robinhood data (along with 15,000+ other financial institutions). This is strongly recommended for any production or team-facing tool. To get started with Plaid: Create an account at https://plaid.com and get your API keys from the Plaid Dashboard. Plaid offers a free Development environment with sandbox data. Create a Plaid REST API Resource in Retool: - Base URL: https://sandbox.plaid.com (for testing) or https://production.plaid.com - Headers: Content-Type: application/json - PLAID-CLIENT-ID: {{ retoolContext.configVars.PLAID_CLIENT_ID }} - PLAID-SECRET: {{ retoolContext.configVars.PLAID_SECRET }} Plaid requires an access_token per connected user account (obtained via Plaid Link, their client-side connection widget). Once a user has linked their Robinhood account through Plaid Link, you store their Plaid access_token and use it for API calls. Fetch holdings: POST /investments/holdings/get with body {"access_token": "access-sandbox-xxx", "client_id": "...", "secret": "..."}. The response includes holdings (positions), securities (security metadata like ticker, name, ISIN), and accounts (account information). All fields are standardized across brokerages — Robinhood, Schwab, and Fidelity return the same field names through Plaid, making multi-broker dashboards straightforward.

1// Plaid holdings transformer - normalized across all brokerages
2const holdings = data.holdings || [];
3const securities = data.securities || [];
4const accounts = data.accounts || [];
5
6// Create lookup maps
7const securityMap = {};
8securities.forEach(s => securityMap[s.security_id] = s);
9const accountMap = {};
10accounts.forEach(a => accountMap[a.account_id] = a);
11
12return holdings.map(h => {
13  const security = securityMap[h.security_id] || {};
14  const account = accountMap[h.account_id] || {};
15  return {
16    ticker: security.ticker_symbol || 'N/A',
17    security_name: security.name || 'Unknown',
18    type: security.type || '',
19    account_name: account.name || '',
20    institution: account.official_name || '',
21    quantity: h.quantity,
22    price: h.institution_price,
23    cost_basis: h.cost_basis,
24    market_value: h.quantity * h.institution_price,
25    unrealized_pl: h.quantity * h.institution_price - (h.cost_basis || 0)
26  };
27});

Whether using the unofficial Robinhood API or Plaid, the dashboard UI components are the same. Build a three-section layout: Top row: Stat components showing Total Portfolio Value, Day Change ($), Day Change (%), and Total Return (all-time). Use colored background conditions on the Day Change stats to show green for positive, red for negative. Middle section: A Table showing individual positions with columns: Ticker Symbol, Security Name, Quantity, Average Cost, Current Price, Market Value, Unrealized Gain/Loss ($), Unrealized Gain/Loss (%). Add conditional column formatting — green for positive gains, red for negative. Bottom section: Two Chart components side by side. Left: a Pie chart showing portfolio allocation by position or sector. Right: a Bar chart showing top gainers and losers by percentage. For historical performance, add a Line chart for portfolio value over time. This requires time-series data from Robinhood's /portfolios/historicals/ endpoint (unofficial) or Plaid's /investments/transactions/get endpoint (official). Add an Export CSV button that downloads the current positions Table using Retool's built-in CSV export functionality (Table component → Download button in settings). For complex multi-brokerage dashboards combining Plaid data with your internal database, RapidDev's team can help architect the data model and build the Retool queries.

1// Portfolio summary stats from positions data
2const positions = getPositions.data || [];
3
4const totalMarketValue = positions.reduce((sum, p) => sum + (p.market_value || 0), 0);
5const totalCostBasis = positions.reduce((sum, p) => sum + (p.cost_basis || p.total_cost || 0), 0);
6const totalUnrealizedPL = totalMarketValue - totalCostBasis;
7const totalReturnPct = totalCostBasis > 0 ? (totalUnrealizedPL / totalCostBasis) * 100 : 0;
8
9return {
10  total_value: totalMarketValue.toFixed(2),
11  total_cost: totalCostBasis.toFixed(2),
12  unrealized_pl: totalUnrealizedPL.toFixed(2),
13  return_pct: totalReturnPct.toFixed(2),
14  position_count: positions.length
15};