--- name: pp-robinhood description: "Printing Press CLI + MCP for the whole of Robinhood — brokerage accounts (individual + retirement), positions, options + chains, portfolio performance, transfers, dividends, orders, watchlists, plus the official Crypto Trading API as the documented subset. Live reads; writes are dry-run gated." author: "zaydiscold" license: "Apache-2.0" argument-hint: " [args] | install cli|mcp" allowed-tools: "Read Bash" metadata: openclaw: requires: bins: - robinhood-pp-cli --- # Robinhood — Printing Press CLI ## Prerequisites: Install the CLI This skill drives the `robinhood-pp-cli` binary. **You must verify the CLI is installed before invoking any command from this skill.** If it is missing, install it first: 1. Install via the Printing Press installer. It defaults binaries to `$HOME/.local/bin` on macOS/Linux and `%LOCALAPPDATA%\Programs\PrintingPress\bin` on Windows: ```bash npx -y @mvanhorn/printing-press-library install robinhood --cli-only ``` 2. Verify: `robinhood-pp-cli --version` 3. Ensure the reported install directory is on `$PATH` for the agent/runtime that will invoke this skill. If the `npx` install fails (no Node, offline, etc.), fall back to a direct Go install (requires Go 1.26.6 or newer): ```bash go install github.com/mvanhorn/printing-press-library/library/payments/robinhood/cmd/robinhood-pp-cli@latest ``` If `--version` reports "command not found" after install, the runtime cannot see the binary directory on `$PATH`. Do not proceed with skill commands until verification succeeds. ## Agent Rules Use read commands and route-map inspection freely. Robinhood Crypto and brokerage/account write routes are PP-gated: they default to `--dry-run`, live execution requires `--live-write`, and the environment must include `ROBINHOOD_PP_ALLOW_WRITES=1`. Never set that gate unless the user explicitly approves the exact live mutation. The package bundles authenticated browser route maps: ```bash robinhood-pp-cli brokerage summary --json robinhood-pp-cli brokerage routes --host api.robinhood.com --json robinhood-pp-cli brokerage browser-routes --host bonfire.robinhood.com --json robinhood-pp-cli brokerage plan https://api.robinhood.com/goku/lcm --json ``` `brokerage execute` can use caller-owned `ROBINHOOD_BROKERAGE_TOKEN` or `ROBINHOOD_COOKIE`. Write routes still require `ROBINHOOD_PP_ALLOW_WRITES=1`. ### Typed brokerage commands (stocks, options, accounts, transfers) Beyond the route map, the `brokerage` group exposes **typed read commands** for the captured brokerage API surface. These are the everyday stock/options/account commands. They authenticate with the same OAuth bearer credential as `brokerage execute` — set `ROBINHOOD_BROKERAGE_TOKEN` (or `ROBINHOOD_COOKIE` + `ROBINHOOD_CSRF_TOKEN`). This is a **separate credential** from the crypto API's `ROBINHOOD_API_KEY` / `ROBINHOOD_PRIVATE_KEY_B64`: the `crypto` group speaks the official signed Crypto API, the `brokerage` group speaks the OAuth-bearer brokerage hosts (`api.robinhood.com`, `bonfire.robinhood.com`, `minerva.robinhood.com`). ```bash # Accounts — Zayd has multiple individual + a retirement account robinhood-pp-cli brokerage accounts --json # every account robinhood-pp-cli brokerage portfolios --json # per-account dollar balances (the "main" balance) robinhood-pp-cli brokerage account --account-id 1AB23456 --json # unified balance for one account # Positions / orders / quotes robinhood-pp-cli brokerage positions --nonzero --json robinhood-pp-cli brokerage orders --json robinhood-pp-cli brokerage quote --symbols AAPL,TSLA --json robinhood-pp-cli brokerage instrument --symbol AAPL --json # Options — positions, orders, chain, contracts, greeks robinhood-pp-cli brokerage options positions --json robinhood-pp-cli brokerage options orders --json robinhood-pp-cli brokerage options chain --chain-id --json robinhood-pp-cli brokerage options instruments --chain-id --expiration 2026-06-19 --type call --json robinhood-pp-cli brokerage options marketdata --instruments --json # Performance windows — YTD, week, month, year, 5year, all robinhood-pp-cli brokerage performance --account-id 1AB23456 --span year --json robinhood-pp-cli brokerage performance --account-id 1AB23456 --span week --interval day --json # Transfers / deposits / withdrawals, dividends, account history robinhood-pp-cli brokerage transfers --json robinhood-pp-cli brokerage transfers relationships --json robinhood-pp-cli brokerage dividends --json robinhood-pp-cli brokerage history --json ``` **Write commands default to dry-run and never auto-execute a trade.** Order placement and cancellation print the exact request and require both `--live-write` and `ROBINHOOD_PP_ALLOW_WRITES=1` for a live mutation — Zayd executes real trades himself. Watchlist add/remove are reversible writes but follow the same gate. ```bash robinhood-pp-cli brokerage orders place --body-json '{"symbol":"AAPL","side":"buy","type":"market","quantity":"1","time_in_force":"gfd"}' --dry-run robinhood-pp-cli brokerage orders cancel --order-id --dry-run robinhood-pp-cli brokerage options place --body-json '{"direction":"debit","type":"limit","legs":[]}' --dry-run robinhood-pp-cli brokerage options cancel --order-id --dry-run robinhood-pp-cli brokerage watchlist add --list-id --body-json '{"object_id":"","object_type":"instrument","operation":"create"}' --dry-run robinhood-pp-cli brokerage watchlist remove --list-id --body-json '{"object_id":"","object_type":"instrument","operation":"delete"}' --dry-run ``` # Introduction Welcome to Robinhood Crypto Trading API documentation for traders and developers! The API lets you view crypto market data, access your account information, and place crypto orders programmatically. To get started, head to your [crypto account settings](https://robinhood.com/account/crypto) on web classic to create credentials. There are two versions of the Crypto Trading API, giving you the option to place crypto orders with fee tiers (v2) or without fee tiers (v1). All read-only API actions are available on both versions. For more information about API version differences, fee tiers, and answers to common questions, visit our [Help Center](https://robinhood.com/us/en/support/articles/crypto-api). You can also view the [Fee Schedule](https://cdn.robinhood.com/assets/robinhood/legal/rhc-fee-schedule.pdf) for the latest rates. The Robinhood Crypto Trading API is available to customers in the United States only. Use of the Robinhood Crypto Trading API is subject to the [Robinhood Crypto Customer Agreement](https://cdn.robinhood.com/assets/robinhood/legal/Robinhood%20Crypto%20Customer%20Agreement.pdf) as well as all other terms and disclosures made available on [Robinhood Crypto's about page](https://robinhood.com/us/en/about/crypto). # Authentication To get started with the Robinhood Crypto Trading API, you need to create a key, signature, and headers. Authenticated requests must include all three `x-api-key`, `x-signature`, and `x-timestamp` HTTP headers. ## Creating an API key Head to your [crypto account settings](https://robinhood.com/account/crypto) on web classic to create credentials. After creating credentials, you will receive the API key associated with the credential. You can modify, disable, and delete credentials you created at any time. Your API key will be used as the `x-api-key` header you will need to pass during authentication when calling our API endpoints. Additionally, you will need the public key generated in the [Creating a key pair](#section/Authentication/Creating-a-key-pair) section to create your API credentials. ## Creating a key pair #### Below are example scripts on how to generate the public and private key pair. You'll need the public key for creating an API credential and the private key for authenticating requests. Remember to never share your private key with anyone. Robinhood will never ask you to share it with us. We highly recommend saving your private and public keys in an encrypted format to ensure the highest level of security. Encrypting your keys will protect them from unauthorized access or theft. Avoid saving them in plain text or any easily accessible location. Instead, consider using strong encryption algorithms or tools specifically designed for key storage. Remember to choose a strong passphrase for encryption and store it separately from your keys. By taking these precautions, you can significantly reduce the risk of compromising your keys and safeguard your sensitive information. ### Python Note that you'll need to have `pynacl` installed to run the Python script. You can install them with the following pip command in your terminal. ```console pip install pynacl ``` ```python import nacl.signing import base64 # Generate an Ed25519 keypair private_key = nacl.signing.SigningKey.generate() public_key = private_key.verify_key # Convert keys to base64 strings private_key_base64 = base64.b64encode(private_key.encode()).decode() public_key_base64 = base64.b64encode(public_key.encode()).decode() # Print the keys in base64 format print("Private Key (Base64):") print(private_key_base64) print("Public Key (Base64):") print(public_key_base64) ``` ## Headers and Signature # Making your first API call Developing your own application to place trades with your Robinhood account is quick and simple. Once you've finished [authentication](https://docs.robinhood.com/crypto/trading/#section/Authentication), start here with the code you'll need to access the API and make supported API calls. These are essentially the building blocks of code for each API call, which you can easily build on based on your preferred strategies. 1. Create a script file ```console mkdir robinhood-api-trading && cd robinhood-api-trading touch robinhood_api_trading.py touch robinhood_api_trading_v2.py ``` 2. Install PyNaCl library ```console pip install pynacl ``` 3. To use v1 endpoints, copy the script below into the newly created `robinhood_api_trading.py` file. Make sure to add your API key and secret key into the `API_KEY` and `BASE64_PRIVATE_KEY` variables. ```python import base64 import datetime import json from typing import Any, Dict, Optional import uuid import requests from nacl.signing import SigningKey API_KEY = "ADD YOUR API KEY HERE" BASE64_PRIVATE_KEY = "ADD YOUR PRIVATE KEY HERE" class CryptoAPITrading: def __init__(self): self.api_key = API_KEY private_key_seed = base64.b64decode(BASE64_PRIVATE_KEY) self.private_key = SigningKey(private_key_seed) self.base_url = "https://trading.robinhood.com" @staticmethod def _get_current_timestamp() -> int: return int(datetime.datetime.now(tz=datetime.timezone.utc).timestamp()) @staticmethod def get_query_params(key: str, *args: Optional[str]) -> str: if not args: return "" params = [] for arg in args: params.append(f"{key}={arg}") return "?" + "&".join(params) def make_api_request(self, method: str, path: str, body: str = "") -> Any: timestamp = self._get_current_timestamp() headers = self.get_authorization_header(method, path, body, timestamp) url = self.base_url + path try: response = {} if method == "GET": response = requests.get(url, headers=headers, timeout=10) elif method == "POST": response = requests.post(url, headers=headers, json=json.loads(body), timeout=10) return response.json() except requests.RequestException as e: print(f"Error making API request: {e}") return None def get_authorization_header( self, method: str, path: str, body: str, timestamp: int ) -> Dict[str, str]: message_to_sign = f"{self.api_key}{timestamp}{path}{method}{body}" signed = self.private_key.sign(message_to_sign.encode("utf-8")) return { "x-api-key": self.api_key, "x-signature": base64.b64encode(signed.signature).decode("utf-8"), "x-timestamp": str(timestamp), } def get_account(self) -> Any: path = "/api/v1/crypto/trading/accounts/" return self.make_api_request("GET", path) # The symbols argument must be formatted in trading pairs, e.g "BTC-USD", "ETH-USD". If no symbols are provided, # all supported symbols will be returned def get_trading_pairs(self, *symbols: Optional[str]) -> Any: query_params = self.get_query_params("symbol", *symbols) path = f"/api/v1/crypto/trading/trading_pairs/{query_params}" return self.make_api_request("GET", path) # The asset_codes argument must be formatted as the short form name for a crypto, e.g "BTC", "ETH". If no asset # codes are provided, all crypto holdings will be returned def get_holdings(self, *asset_codes: Optional[str]) -> Any: query_params = self.get_query_params("asset_code", *asset_codes) path = f"/api/v1/crypto/trading/holdings/{query_params}" return self.make_api_request("GET", path) # The symbols argument must be formatted in trading pairs, e.g "BTC-USD", "ETH-USD". If no symbols are provided, # the best bid and ask for all supported symbols will be returned def get_best_bid_ask(self, *symbols: Optional[str]) -> Any: query_params = self.get_query_params("symbol", *symbols) path = f"/api/v1/crypto/marketdata/best_bid_ask/{query_params}" return self.make_api_request("GET", path) # The symbol argument must be formatted in a trading pair, e.g "BTC-USD", "ETH-USD" # The side argument must be "bid", "ask", or "both". # Multiple quantities can be specified in the quantity argument, e.g. "0.1,1,1.999". def get_estimated_price(self, symbol: str, side: str, quantity: str) -> Any: path = f"/api/v1/crypto/marketdata/estimated_price/?symbol={symbol}&side={side}&quantity={quantity}" return self.make_api_request("GET", path) def place_order( self, client_order_id: str, side: str, order_type: str, symbol: str, order_config: Dict[str, str], ) -> Any: body = { "client_order_id": client_order_id, "side": side, "type": order_type, "symbol": symbol, f"{order_type}_order_config": order_config, } path = "/api/v1/crypto/trading/orders/" return self.make_api_request("POST", path, json.dumps(body)) def cancel_order(self, order_id: str) -> Any: path = f"/api/v1/crypto/trading/orders/{order_id}/cancel/" return self.make_api_request("POST", path) def get_order(self, order_id: str) -> Any: path = f"/api/v1/crypto/trading/orders/{order_id}/" return self.make_api_request("GET", path) def get_orders(self) -> Any: path = "/api/v1/crypto/trading/orders/" return self.make_api_request("GET", path) def main(): api_trading_client = CryptoAPITrading() print(api_trading_client.get_account()) """ BUILD YOUR TRADING STRATEGY HERE order = api_trading_client.place_order( str(uuid.uuid4()), "buy", "market", "BTC-USD", {"asset_quantity": "0.0001"} ) """ if __name__ == "__main__": main() ``` 4. To use v2 endpoints, copy the script below into the newly created `robinhood_api_trading_v2.py` file. Make sure to add your API key and secret key into the `API_KEY` and `BASE64_PRIVATE_KEY` variables. ```python import base64 import datetime import json from typing import Any, Dict, Optional import uuid import requests from nacl.signing import SigningKey API_KEY = "ADD YOUR API KEY HERE" BASE64_PRIVATE_KEY = "ADD YOUR PRIVATE KEY HERE" class CryptoAPITradingV2: def __init__(self): self.api_key = API_KEY private_key_seed = base64.b64decode(BASE64_PRIVATE_KEY) self.private_key = SigningKey(private_key_seed) self.base_url = "https://trading.robinhood.com" @staticmethod def _get_current_timestamp() -> int: return int(datetime.datetime.now(tz=datetime.timezone.utc).timestamp()) @staticmethod def get_query_params(params_dict: Dict[str, Any]) -> str: """ Build query parameter string from a dictionary. - Single values: {"key1": "value1", "key2": "value2"} - Multiple values for same key: {"symbol": ["BTC-USD", "ETH-USD"]} """ if not params_dict: return "" params = [] for key, value in params_dict.items(): if value is None: continue if isinstance(value, list): # Handle multiple values for the same key for v in value: params.append(f"{key}={v}") else: params.append(f"{key}={value}") return "?" + "&".join(params) if params else "" def make_api_request(self, method: str, path: str, body: str = "") -> Any: timestamp = self._get_current_timestamp() headers = self.get_authorization_header(method, path, body, timestamp) url = self.base_url + path try: response = {} if method == "GET": response = requests.get(url, headers=headers, timeout=10) elif method == "POST": response = requests.post(url, headers=headers, json=json.loads(body) if body else None, timeout=10) # Check for non-success status codes if response.status_code >= 400: print(f"HTTP Error {response.status_code}: {response.reason}") try: return response.json() except json.JSONDecodeError: return {"error": response.text or response.reason, "status_code": response.status_code} return response.json() except requests.RequestException as e: print(f"Error making API request: {e}") return None def get_authorization_header( self, method: str, path: str, body: str, timestamp: int ) -> Dict[str, str]: message_to_sign = f"{self.api_key}{timestamp}{path}{method}{body}" signed = self.private_key.sign(message_to_sign.encode("utf-8")) return { "x-api-key": self.api_key, "x-signature": base64.b64encode(signed.signature).decode("utf-8"), "x-timestamp": str(timestamp), } def get_accounts(self) -> Any: path = "/api/v2/crypto/trading/accounts/" return self.make_api_request("GET", path) # The symbols argument must be formatted in trading pairs, e.g "BTC-USD", "ETH-USD". If no symbols are provided, # all supported symbols will be returned def get_trading_pairs(self, *symbols: Optional[str]) -> list: params = {"symbol": list(symbols)} if symbols else {} query_params = self.get_query_params(params) path = f"/api/v2/crypto/trading/trading_pairs/{query_params}" all_results = [] response = self.make_api_request("GET", path) while response: results = response.get("results", []) all_results.extend(results) next_url = response.get("next")