KalTrader MCP
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@KalTrader MCP What are the best odds on Kalshi for the Fed cutting rates in September?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
KalTrader
Let Claude, ChatGPT, or any other MCP client use your Kalshi account.
Ask your assistant things like:
Put a resting buy order for 20 contracts at 40 cents on that market.
What are the best odds on Kalshi for the Fed cutting rates in September?
Look at my open positions and tell me which ones are underwater.
Paper trade $50 across the best events right now, then check on it tomorrow.
Not affiliated with Kalshi.
Setup
You need Node.js 22 or newer.
Run the below command in your terminal.
npx kaltrader setupThat opens a page in your browser. Pick the demo exchange or the real one, paste your Kalshi API key, and click the app you want to connect. Restart that app and you are done.
To get a Kalshi API key: go to your Kalshi account settings, open the API keys section, and create a key. Kalshi shows you the key ID and downloads a private key file once. You need both.
The setup page can connect these automatically:
Claude Desktop
Claude Code
Cursor
Windsurf
For anything else, the page gives you a block of JSON to paste into that app's config.
Related MCP server: ai-trader
Where your key goes
Your Kalshi private key never goes into a chat, a config file, or over the internet. The setup page runs on your own machine and talks to nothing but the process that started it.
The key is encrypted with AES-256-GCM and written to ~/.kaltrader/credentials.enc. The key that decrypts it is held by your operating system:
Platform | Where |
macOS | Keychain |
Windows | DPAPI, tied to your Windows login |
Linux | The secret service, through |
If none of those exist, which mostly means a server or a container, the encryption key falls back to a file only your user account can read. Setup and doctor both tell you when that happens.
Before saving anything, setup makes a real signed request to Kalshi. If Kalshi rejects the key, nothing is stored. That catches the most common mistake, which is using a demo key against production.
To remove everything from your machine:
npx kaltrader logoutThat deletes the local copy. Delete the key in Kalshi's dashboard too if you are done with it.
Guardrails
You are giving an AI assistant the ability to spend your money. A few settings limit how much damage a misunderstanding can do.
Start on the demo exchange. It works the same way with play money. This is the default.
npx kaltrader config --environment demoRead-only mode. The assistant can see markets and your account but cannot place, change, or cancel orders. Write endpoints are not just blocked, they are not offered.
npx kaltrader config --read-only trueA per-order dollar limit. Any single order risking more than this is refused before it leaves your machine. For a buy, the risk is the price paid. For a sell, it is the rest of the dollar, because Kalshi contracts settle at either $1.00 or $0.00.
npx kaltrader config --max-order-usd 25None of this replaces watching what your assistant does. Check your open orders on Kalshi.
Paper trading
Simulated portfolios, priced off the live exchange. Nothing reaches Kalshi: no order is placed, no money moves, and the position exists only in ~/.kaltrader/paper.json.
Paper trade $50. Find three markets you think are mispriced and put money on them.
How is my paper portfolio doing?
This is not Kalshi's demo exchange. Demo needs its own account and has its own thin, separate order book, so a strategy that works there tells you little. Paper trading reads the real production book, fills against real resting orders, charges Kalshi's usual fees, and pays out when the real market settles. The only fiction is that your order was never actually there.
Four tools, always loaded:
kalshi_paper_orderplaces a simulated order. Market orders walk the real book and pay the taker fee. Limit orders fill whatever crosses and leave the rest resting.kalshi_paper_portfoliovalues everything against live prices: cash, each position marked at what it could be sold for, realized and unrealized P&L, fees, and total return.kalshi_paper_cancelcancels a resting order.kalshi_paper_resetstarts a portfolio over with a new balance, or deletes it.
Name a portfolio to run several at once and compare them:
Run the same $100 two ways: one paper portfolio buying favourites, one buying longshots.
Nothing runs in the background, because an MCP server has nowhere to run it. A portfolio catches up when you look at it: asking for the portfolio is what settles finished markets, fills resting orders, and re-marks positions. Ask your assistant to check in every morning and you get the same effect.
What is simulated honestly: fills against real book depth, Kalshi's 7% trading fee on taker fills, cash reserved against resting orders, positions netting through zero when you flip sides, and settlement at $1.00 or $0.00. What is not: queue position, trades that happen between two checks, per-series fee schedules, and the fact that your own order would have moved the book.
Positions are marked at the bid, which is what you could actually sell for, not the midpoint. On a wide spread that looks pessimistic. It is the honest number.
Read-only mode does not disable this, and neither does the per-order limit. Both exist to stop real money moving, and paper trading never moves any. To switch it off entirely:
npx kaltrader config --paper falseToolsets
Kalshi has 137 endpoints. Loading all of them at once costs your assistant about 40,000 tokens before it has done anything, so related endpoints are grouped and only four groups are on by default.
npx kaltrader toolsets on markets 23 Markets, events, series, order books, trades, candlesticks, and search.
on exchange 4 Exchange status, trading hours, and fee change announcements.
on portfolio 14 Balance, positions, fills, settlements, deposits, withdrawals, and subaccounts.
on orders 10 Place, amend, decrease, and cancel orders, plus queue positions.
off order-groups 7 Order groups, which cap total exposure across a set of orders.
off historical 8 Settled markets, trades, fills, orders, and positions older than the live cutoff.
off live-data 5 Live sports scores, game stats, and milestone data attached to markets.
off multivariate 4 Multivariate event collections and combined-outcome markets.
off communications 18 Requests for quote, quotes, and block trade proposals.
off account 8 API keys, rate limit tiers, and endpoint costs.
off fcm 2 Futures commission merchant orders and positions.
off perps 34 Perpetual futures: margin markets, orders, positions, funding, and risk.Turn on what you need, or all of it:
npx kaltrader config --toolsets markets,orders,portfolio,perps
npx kaltrader config --toolsets allSwitching a group off does not put those endpoints out of reach. Four tools are always loaded and cover the whole API:
kalshi_list_endpointssearches all 137 by keyword.kalshi_describe_endpointshows the fields one endpoint takes.kalshi_call_endpointcalls any of them.kalshi_server_inforeports how the server is set up, which is the first thing to check when something fails.
There is also kalshi_stream_collect, which connects to Kalshi's WebSocket feed, listens for a few seconds, and returns what arrived. Useful for watching an order book move. It is a one-shot capture, since a tool call cannot stay subscribed.
Every endpoint is listed in docs/endpoints.md.
ChatGPT
ChatGPT connectors only talk to public HTTPS addresses. They cannot reach your computer, so this takes an extra step.
Run the server over HTTP:
npx kaltrader httpIt prints a connection token. Then put it behind a public address, for example with cloudflared:
cloudflared tunnel --url http://127.0.0.1:8765Give ChatGPT the HTTPS address it prints with /mcp on the end, and the token as a bearer header. If ChatGPT will only accept a URL, put the token in the path instead: https://your-tunnel/<token>/mcp.
While that tunnel is open, anyone with the address and the token can trade on your account. Turn it off when you are finished. Read-only mode is a sensible pairing here.
Commands
kaltrader Run the server over stdio. This is what AI apps call.
kaltrader setup Open the browser page to save a key and connect an app.
kaltrader http [--port N] Run the server over HTTP, for remote clients.
kaltrader doctor Check the saved key, the config, and the connection to Kalshi.
kaltrader config [flags] Show or change settings.
kaltrader toolsets List the endpoint groups.
kaltrader install <app> Add the server to an app's config file.
kaltrader logout Delete every saved key from this computer.When something is not working, start with doctor. It prints where your settings live, which storage backend holds your key, and whether Kalshi accepts it right now.
Environment variables
Useful for containers and CI, where there is no keychain and no browser.
Variable | Does what |
| API key ID. Skips the keystore entirely. |
| The private key itself. Escaped |
| Path to the private key file, instead of the above. |
|
|
| Comma-separated list, or |
|
|
| Per-order dollar limit. |
|
|
| Where settings live. Defaults to |
|
|
How it is built
The tool list is generated from Kalshi's own OpenAPI specs, which are checked into specs/. A build step turns every operation into an MCP tool with a JSON Schema for its arguments. Nothing is hand-written per endpoint, so when Kalshi adds something, refreshing the spec picks it up.
Arguments are checked against that schema before a request goes out. A missing required field comes back as a sentence naming the field, rather than a 400 from Kalshi that the assistant has to guess at.
Requests are signed with RSA-PSS over timestamp + method + path, which is what Kalshi expects. Every request gets signed when a key is loaded, including public endpoints, because rate limits are per account and unsigned traffic shares a smaller pool.
More detail in docs/architecture.md and docs/security.md.
Working on it
git clone https://github.com/SakethSripada/KalTraderMCP
cd KalTraderMCP
npm install
npm run build
npm testnpm run specs:refresh Re-download Kalshi's API specs
npm run build:spec Regenerate the tool table from them
npm run typecheck Types onlyTo point an AI app at your working copy instead of the published package, use node /path/to/repo/dist/cli.js as the command.
A word on risk
Prediction market contracts can settle at zero. An AI assistant will occasionally misread a market, a ticker, or you. Use the demo exchange until you trust what you are seeing, keep the per-order limit low when you switch to real money, and look at your account yourself.
This project is not affiliated with, endorsed by, or connected to Kalshi.
License
MIT. See LICENSE.
Available Tools
60 toolskalshi_amend_order_v2A
Amend Order (V2) Endpoint for amending the price and/or max fillable count of an existing event-market order using the V2 request/response shape. The request count is the updated total/max fillable count, equal to already filled count plus desired resting remaining count. This behavior matches the v1 amend endpoints; only the request/response shape differs. Calls POST /portfolio/events/orders/{order_id}/amend.
Inputs: side (required), count (required), price (required), ticker (required), +5 more.
kalshi_apply_subaccount_transferB
Transfer Between Subaccounts Transfers funds between the authenticated user's subaccounts. Use 0 for the primary account, or 1-63 for numbered subaccounts. Set exchange_index to apply the transfer on a specific exchange shard (defaults to 0). Calls POST /portfolio/subaccounts/transfer.
Inputs: amount_cents (required), to_subaccount (required), from_subaccount (required), client_transfer_id (required), +1 more.
kalshi_batch_cancel_orders_v2ADestructive
Batch Cancel Orders (V2) Endpoint for cancelling a batch of event-market orders using the V2 response shape. The maximum batch size scales with your tier's write budget — see Rate Limits and Tiers. Calls DELETE /portfolio/events/orders/batched.
Inputs: orders (required).
kalshi_batch_create_orders_v2A
Batch Create Orders (V2) Endpoint for submitting a batch of event-market orders using the V2 request/response shape. The maximum batch size scales with your tier's write budget — see Rate Limits and Tiers. Calls POST /portfolio/events/orders/batched.
Inputs: orders (required).
kalshi_batch_get_market_candlesticksARead-only
Batch Get Market Candlesticks Endpoint for retrieving candlestick data for multiple markets. - Accepts up to 100 market tickers per request - Returns up to 10,000 candlesticks total across all markets - Returns candlesticks grouped by market_id - Optionally includes a synthetic initial candlestick for price continuity (see include_latest_before_start parameter) Calls GET /markets/candlesticks.
Inputs: end_ts (required), start_ts (required), market_tickers (required), period_interval (required), +1 more.
kalshi_call_endpointA
Call any Kalshi API endpoint directly, including ones with no dedicated tool loaded. Paths are relative to /trade-api/v2, so use "/markets" rather than the full URL. Prefer a dedicated tool when one exists, since those validate arguments for you.
Inputs: path (required), method (required), body, query.
kalshi_cancel_order_v2ADestructive
Cancel Order (V2) Endpoint for cancelling event-market orders using the V2 response shape. Returns {order_id, client_order_id, reduced_by} rather than a full order object. Calls DELETE /portfolio/events/orders/{order_id}.
Inputs: order_id (required), subaccount, market_ticker, exchange_index.
kalshi_create_order_v2A
Create Order (V2) Endpoint for submitting event-market orders using the V2 request/response shape (single-book bid/ask side and fixed-point dollar prices). The legacy /portfolio/orders endpoint will be deprecated no earlier than May 6, 2026 — clients should migrate to this path. Calls POST /portfolio/events/orders.
Inputs: side (required), count (required), price (required), ticker (required), +10 more.
kalshi_create_subaccountA
Create Subaccount Creates a new subaccount for the authenticated user. This endpoint is available to all users on the Advanced API tier and above. Subaccounts are numbered sequentially starting from 1. Maximum 63 numbered subaccounts per user (64 including the primary account). Calls POST /portfolio/subaccounts.
Inputs: exchange_index.
kalshi_decrease_order_v2A
Decrease Order (V2) Endpoint for decreasing the remaining count of an existing event-market order using the V2 request/response shape. Exactly one of reduce_by or reduce_to must be provided. Calls POST /portfolio/events/orders/{order_id}/decrease.
Inputs: order_id (required), reduce_by, reduce_to, subaccount, +2 more.
kalshi_describe_endpointA
Show the full input schema for one Kalshi endpoint: every path, query, and body field with its type and description. Look here before calling kalshi_call_endpoint.
Inputs: endpoint (required).
kalshi_get_balanceARead-only
Get Balance Endpoint for getting the balance and portfolio value of a member. Both values are returned in cents. This endpoint also accepts API keys with the 'read::portfolio_balance' scope. Calls GET /portfolio/balance.
Inputs: subaccount, exchange_index.
kalshi_get_depositsBRead-only
Get Deposits Endpoint for getting the member's deposit history. Calls GET /portfolio/deposits.
Inputs: limit, cursor.
kalshi_get_eventARead-only
Get Event Endpoint for getting data about an event by its ticker. An event represents a real-world occurrence that can be traded on, such as an election, sports game, or economic indicator release. Events contain one or more markets where users can place trades on different outcomes. All events are accessible through this endpoint, even if their associated markets are older than the historical cutoff. Calls GET /events/{event_ticker}.
Inputs: event_ticker (required), with_nested_markets.
kalshi_get_event_fee_changesBRead-only
Get Event Fee Changes Event fees are an override layered on top of the parent series' fee structure. If fee_type_override and fee_multiplier_override are null, that indicates the override is cleared. Calls GET /events/fee_changes.
Inputs: limit, cursor, event_ticker.
kalshi_get_event_forecast_percentilesARead-only
Get Event Forecast Percentile History Endpoint for getting the historical raw and formatted forecast numbers for an event at specific percentiles. Calls GET /series/{series_ticker}/events/{ticker}/forecast_percentile_history.
Inputs: end_ts (required), ticker (required), start_ts (required), percentiles (required), +2 more.
kalshi_get_event_metadataARead-only
Get Event Metadata Endpoint for getting metadata about an event by its ticker. Returns only the metadata information for an event. Calls GET /events/{event_ticker}/metadata.
Inputs: event_ticker (required).
kalshi_get_eventsARead-only
Get Events Get all events. This endpoint excludes multivariate events. To retrieve multivariate events, use the GET /events/multivariate endpoint. All events are accessible through this endpoint, even if their associated markets are older than the historical cutoff. Calls GET /events.
Inputs: limit, cursor, status, tickers, +5 more.
kalshi_get_exchange_scheduleBRead-only
Get Exchange Schedule Endpoint for getting the exchange schedule. Calls GET /exchange/schedule.
Inputs: no named parameters.
kalshi_get_exchange_statusARead-only
Get Exchange Status Endpoint for getting the exchange status. Calls GET /exchange/status.
Inputs: no named parameters.
kalshi_get_fillsARead-only
Get Fills Endpoint for getting all fills for the member. A fill is when a trade you have is matched. Fills that occurred before the historical cutoff are only available via GET /historical/fills. See Historical Data for details. Calls GET /portfolio/fills.
Inputs: limit, cursor, max_ts, min_ts, +3 more.
kalshi_get_filters_for_sportsARead-only
Get Filters for Sports Retrieve available filters organized by sport. This endpoint returns filtering options available for each sport, including scopes and competitions. It also provides an ordered list of sports for display purposes. Calls GET /search/filters_by_sport.
Inputs: no named parameters.
kalshi_get_incentive_programsBRead-only
Get Incentives List incentives with optional filters. Incentives are rewards programs for trading activity on specific markets. Calls GET /incentive_programs.
Inputs: type, limit, cursor, status, +1 more.
kalshi_get_marketARead-only
Get Market Endpoint for getting data about a specific market by its ticker. A market represents a specific binary outcome within an event that users can trade on (e.g., "Will candidate X win?"). Markets have yes/no positions, current prices, volume, and settlement rules. Calls GET /markets/{ticker}.
Inputs: ticker (required).
kalshi_get_market_candlesticksARead-only
Get Market Candlesticks Time period length of each candlestick in minutes. Valid values: 1 (1 minute), 60 (1 hour), 1440 (1 day). Candlesticks for markets that settled before the historical cutoff are only available via GET /historical/markets/{ticker}/candlesticks. See Historical Data for details. Calls GET /series/{series_ticker}/markets/{ticker}/candlesticks.
Inputs: end_ts (required), ticker (required), start_ts (required), series_ticker (required), +2 more.
kalshi_get_market_candlesticks_by_eventARead-only
Get Event Candlesticks End-point for returning aggregated data across all markets corresponding to an event. Calls GET /series/{series_ticker}/events/{ticker}/candlesticks.
Inputs: end_ts (required), ticker (required), start_ts (required), series_ticker (required), +1 more.
kalshi_get_market_orderbookARead-only
Get Market Orderbook Endpoint for getting the current order book for a specific market. The order book shows all active bid orders for both yes and no sides of a binary market. It returns yes bids and no bids only (no asks are returned). This is because in binary markets, a bid for yes at price X is equivalent to an ask for no at price (100-X). For example, a yes bid at 7¢ is the same as a no ask at 93¢, with identical contract sizes. Each side shows price levels with their corresponding quantities and order counts… Calls GET /markets/{ticker}/orderbook.
Inputs: ticker (required), depth.
kalshi_get_market_orderbooksARead-only
Get Multiple Market Orderbooks Endpoint for getting the current order books for multiple markets in a single request. The order book shows all active bid orders for both yes and no sides of a binary market. It returns yes bids and no bids only (no asks are returned). This is because in binary markets, a bid for yes at price X is equivalent to an ask for no at price (100-X). For example, a yes bid at 7¢ is the same as a no ask at 93¢, with identical contract sizes. Each side shows price levels with their corresponding quantit… Calls GET /markets/orderbooks.
Inputs: tickers (required).
kalshi_get_marketsCRead-only
Get Markets Filter by market status. Possible values: unopened, open, closed, settled. Leave empty to return markets with any status. - Only one status filter may be supplied at a time. - Timestamp filters will be mutually exclusive from other timestamp filters and certain status filters. | Compatible Timestamp Filters | Additional Status Filters| Extra Notes | |------------------------------|--------------------------|-------------| | min_created_ts, max_created_ts | unopened, open, empty… Calls GET /markets.
Inputs: limit, cursor, status, tickers, +10 more.
kalshi_get_milestoneARead-only
Get Milestone Endpoint for getting data about a specific milestone by its ID. Calls GET /milestones/{milestone_id}.
Inputs: milestone_id (required).
kalshi_get_milestonesCRead-only
Get Milestones Minimum start date to filter milestones. Format: RFC3339 timestamp Calls GET /milestones.
Inputs: limit (required), type, cursor, category, +5 more.
kalshi_get_multivariate_eventsARead-only
Get Multivariate Events Retrieve multivariate (combo) events. These are dynamically created events from multivariate event collections. Supports filtering by series and collection ticker. Calls GET /events/multivariate.
Inputs: limit, cursor, series_ticker, collection_ticker, +1 more.
kalshi_get_orderBRead-only
Get Order Endpoint for getting a single order. Calls GET /portfolio/orders/{order_id}.
Inputs: order_id (required).
kalshi_get_order_queue_positionARead-only
Get Order Queue Position Endpoint for getting an order's queue position in the order book. This represents the amount of orders that need to be matched before this order receives a partial or full match. Queue position is determined using a price-time priority. Calls GET /portfolio/orders/{order_id}/queue_position.
Inputs: order_id (required).
kalshi_get_order_queue_positionsARead-only
Get Queue Positions for Orders Endpoint for getting queue positions for all resting orders. Queue position represents the number of contracts that need to be matched before an order receives a partial or full match, determined using price-time priority. Calls GET /portfolio/orders/queue_positions.
Inputs: subaccount, event_ticker, market_tickers.
kalshi_get_ordersARead-only
Get Orders Restricts the response to orders that have a certain status: resting, canceled, or executed. Orders that have been canceled or fully executed before the historical cutoff are only available via GET /historical/orders. Resting orders will always be available through this endpoint. See Historical Data for details. Calls GET /portfolio/orders.
Inputs: limit, cursor, max_ts, min_ts, +4 more.
kalshi_get_positionsCRead-only
Get Positions Restricts the positions to those with any of following fields with non-zero values, as a comma separated list. The following values are accepted: position, total_traded Calls GET /portfolio/positions.
Inputs: limit, cursor, ticker, subaccount, +2 more.
kalshi_get_seriesARead-only
Get Series Endpoint for getting data about a specific series by its ticker. A series represents a template for recurring events that follow the same format and rules (e.g., "Monthly Jobs Report", "Weekly Initial Jobless Claims", "Daily Weather in NYC"). Series define the structure, settlement sources, and metadata that will be applied to each recurring event instance within that series. Calls GET /series/{series_ticker}.
Inputs: series_ticker (required), include_volume.
kalshi_get_series_fee_changesCRead-only
Get Series Fee Changes Calls GET /series/fee_changes.
Inputs: series_ticker, show_historical.
kalshi_get_series_listARead-only
Get Series List Endpoint for getting data about multiple series with specified filters. A series represents a template for recurring events that follow the same format and rules (e.g., "Monthly Jobs Report", "Weekly Initial Jobless Claims", "Daily Weather in NYC"). This endpoint allows you to browse and discover available series templates by category. Calls GET /series.
Inputs: tags, category, include_volume, min_updated_ts, +1 more.
kalshi_get_settlementsBRead-only
Get Settlements Endpoint for getting the member's settlements historical track. Calls GET /portfolio/settlements.
Inputs: limit, cursor, max_ts, min_ts, +3 more.
kalshi_get_structured_targetARead-only
Get Structured Target Endpoint for getting data about a specific structured target by its ID. Calls GET /structured_targets/{structured_target_id}.
Inputs: structured_target_id (required).
kalshi_get_structured_targetsBRead-only
Get Structured Targets Page size (min: 1, max: 2000) Calls GET /structured_targets.
Inputs: ids, type, cursor, page_size, +1 more.
kalshi_get_subaccount_balancesARead-only
Get All Subaccount Balances Gets balances for all subaccounts including the primary account. Calls GET /portfolio/subaccounts/balances.
Inputs: no named parameters.
kalshi_get_subaccount_nettingARead-only
Get Subaccount Netting Gets the netting enabled settings for all subaccounts. Calls GET /portfolio/subaccounts/netting.
Inputs: no named parameters.
kalshi_get_subaccount_transfersARead-only
Get Subaccount Transfers Gets a paginated list of all transfers between subaccounts for the authenticated user. Calls GET /portfolio/subaccounts/transfers.
Inputs: limit, cursor.
kalshi_get_tags_for_series_categoriesARead-only
Get Tags for Series Categories Retrieve tags organized by series categories. This endpoint returns a mapping of series categories to their associated tags, which can be used for filtering and search functionality. Calls GET /search/tags_by_categories.
Inputs: no named parameters.
kalshi_get_total_resting_order_valueARead-only
Get Total Resting Order Value Endpoint for getting the total value, in cents, of resting orders. This endpoint is only intended for use by FCM members (rare). Note: If you're uncertain about this endpoint, it likely does not apply to you. Calls GET /portfolio/summary/total_resting_order_value.
Inputs: no named parameters.
kalshi_get_tradesARead-only
Get Trades Endpoint for getting all trades for all markets. A trade represents a completed transaction between two users on a specific market. Each trade includes the market ticker, price, quantity, and timestamp information. Block trades are included in the response by default and identified by the is_block_trade field; use the is_block_trade query parameter to filter by block / non-block. This endpoint returns a paginated response. Use the 'limit' parameter to control page size (1-1000, defaults to… Calls GET /markets/trades.
Inputs: limit, cursor, max_ts, min_ts, +2 more.
kalshi_get_user_data_timestampARead-only
Get User Data Timestamp There is typically a short delay before exchange events are reflected in the API endpoints. Whenever possible, combine API responses to PUT/POST/DELETE requests with WebSocket data to obtain the most accurate view of the exchange state. This endpoint provides an approximate indication of when the data from the following endpoints was last validated: GetBalance, GetOrder(s), GetFills, GetPositions Calls GET /exchange/user_data_timestamp.
Inputs: no named parameters.
kalshi_get_withdrawalsARead-only
Get Withdrawals Endpoint for getting the member's withdrawal history. Calls GET /portfolio/withdrawals.
Inputs: limit, cursor.
kalshi_intra_exchange_instance_transferB
Intra Account Transfer Endpoint for transferring funds within the same account. Calls POST /portfolio/intra_exchange_instance_transfer.
Inputs: amount (required), source (required), destination (required), source_exchange_shard, +1 more.
kalshi_list_endpointsA
Search every Kalshi API endpoint, including ones not currently loaded as their own tool. Use this to find an endpoint by keyword, then call it with kalshi_call_endpoint. Returns the method, path, toolset, and whether a dedicated tool for it is loaded right now.
Inputs: limit, search, toolset.
kalshi_paper_cancelA
Cancel a resting simulated order and release the cash it was holding. Use kalshi_paper_portfolio to see order ids.
Inputs: order_id (required), portfolio.
kalshi_paper_orderA
Place a simulated order against the live Kalshi book. Nothing here reaches Kalshi: no real order is placed and no real money moves. Prices, fills, and settlement follow the live exchange, so the numbers track a real strategy, but the position exists only on this computer. Market orders fill immediately by walking the real order book, paying Kalshi's usual taker fee. Limit orders fill any part that crosses right now and leave the rest resting, to be matched the next time a paper tool runs. The portfolio is created on first use with a starting balance you can set here or with kalshi_paper_reset.
Inputs: count (required), action (required), ticker (required), side, +4 more.
kalshi_paper_portfolioA
Value a simulated portfolio against live Kalshi prices: cash, every open position marked at what it could be sold for right now, realized and unrealized P&L, fees, and total return. Call this to monitor paper positions over time. It also brings the portfolio up to date first, so it is where settled markets get paid out and resting orders get matched.
Inputs: portfolio, fill_limit, include_fills, include_orders.
kalshi_paper_resetA
Create a simulated portfolio, or wipe an existing one back to a fresh cash balance. Positions, orders, and history are discarded. Use this to start a new experiment, for example "paper trade $50".
Inputs: delete, portfolio, starting_balance_usd.
kalshi_server_infoA
Report how this server is configured: which Kalshi environment it targets, whether an API key is loaded, which toolsets are on, and any limits in force. Check this first if a call fails unexpectedly.
Inputs: no named parameters.
kalshi_stream_collectA
Watch Kalshi's WebSocket feed for a few seconds and return the messages that arrive. Useful for seeing live order book changes, trades, or your own fills as they happen. This is a one-shot capture, not an ongoing subscription: it connects, listens for the window you ask for, then disconnects.
Inputs: channels (required), max_messages, market_tickers, duration_seconds.
kalshi_update_subaccount_nettingA
Update Subaccount Netting Updates the netting enabled setting for a specific subaccount. Use 0 for the primary account, or 1-63 for numbered subaccounts. Calls PUT /portfolio/subaccounts/netting.
Inputs: enabled (required), subaccount_number (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 60 tools
Each tool has a clearly distinct resource+action combination. The GET endpoints are differentiated by resource type (markets, events, series, orders, etc.), and write operations (create, amend, cancel, decrease, transfer) are scoped to specific resources. The paper trading tools are explicitly marked as simulated, and the meta tools (list/describe/call endpoint) serve a unique discovery purpose, so there is no meaningful ambiguity.
The majority of tools follow a consistent get_* or verb_noun pattern (e.g., kalshi_get_market, kalshi_create_order_v2). However, there are minor deviations: 'kalshi_paper_order' and 'kalshi_paper_portfolio' lack a verb prefix, 'kalshi_stream_collect' reverses the verb, and 'kalshi_intra_exchange_instance_transfer' is a noun phrase. These are few relative to the total and do not significantly impede readability.
With 60 tools, this server far exceeds the well-scoped threshold. Many endpoints could be served by the generic kalshi_call_endpoint or consolidated into parameterized tools. The count is an extreme mismatch for typical tool-set expectations and likely overwhelms an agent.
The tool surface is exceptionally complete for the Kalshi trading API, covering market data, order management (create, amend, cancel, decrease, batch), portfolio (balance, positions, fills, settlements), subaccounts, and paper trading. The generic kalshi_call_endpoint ensures that even endpoints without dedicated tools are accessible, leaving no obvious gaps.
Maintenance
Related MCP Connectors
Calibrated world model for AI agents. 40 tools: world state, markets, trading. Kalshi + Polymarket.
Connect brokerage accounts to AI assistants: holdings, orders, asset lookup, and approved trading.
Unified financial infrastructure connecting AI agents directly to trade live/demo brokerage accounts, Web3 non-custodial wallets, real-time market data across equities, ETFs, crypto, forex, options, DeFi swaps, and prediction markets, institutional research feeds, and algorithmic strategy backtesters.
Guardrails for trading agents. Built-in risk management, 100+ tools for strategy R&D, 12+ venues.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to securely trade on Hyperliquid perpetual exchange, including order placement, position management, market data retrieval, and vault operations via natural language.23 PyPI24MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants like Claude to run backtests, fetch market data, list strategies, and analyze trading algorithms via natural language.1,141GPL 3.0
- AlicenseNot gradedqualityCmaintenanceMCP server that exposes Kalshi prediction markets as tools for AI agents, enabling conversational trading with safety features like demo mode, preview-before-place, and hard caps.MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to interact with Kalshi event contracts and perpetual markets via a safety-focused MCP interface, with paper trading by default, strict schemas, and fail-closed behavior.Apache 2.0