Skip to main content
Glama
KalTrader MCP

KalTrader MCP

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 setup

That 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 secret-tool

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 logout

That 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 demo

Read-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 true

A 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 25

None 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_order places 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_portfolio values 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_cancel cancels a resting order.

  • kalshi_paper_reset starts 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 false

Toolsets

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 all

Switching a group off does not put those endpoints out of reach. Four tools are always loaded and cover the whole API:

  • kalshi_list_endpoints searches all 137 by keyword.

  • kalshi_describe_endpoint shows the fields one endpoint takes.

  • kalshi_call_endpoint calls any of them.

  • kalshi_server_info reports 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 http

It prints a connection token. Then put it behind a public address, for example with cloudflared:

cloudflared tunnel --url http://127.0.0.1:8765

Give 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

KALSHI_API_KEY_ID

API key ID. Skips the keystore entirely.

KALSHI_PRIVATE_KEY

The private key itself. Escaped \n is fine.

KALSHI_PRIVATE_KEY_FILE

Path to the private key file, instead of the above.

KALTRADER_ENVIRONMENT

demo or production.

KALTRADER_TOOLSETS

Comma-separated list, or all.

KALTRADER_READ_ONLY

true to block every write.

KALTRADER_MAX_ORDER_USD

Per-order dollar limit.

KALTRADER_PAPER_TRADING

false to drop the paper trading tools.

KALTRADER_HOME

Where settings live. Defaults to ~/.kaltrader.

KALTRADER_LOG_LEVEL

debug, info, warn, or error.

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 test
npm run specs:refresh    Re-download Kalshi's API specs
npm run build:spec       Regenerate the tool table from them
npm run typecheck        Types only

To 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 tools
kalshi_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_v2A
Destructive

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_candlesticksA
Read-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_v2A
Destructive

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_balanceA
Read-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_depositsB
Read-only

Get Deposits Endpoint for getting the member's deposit history. Calls GET /portfolio/deposits.

Inputs: limit, cursor.

kalshi_get_eventA
Read-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_changesB
Read-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_percentilesA
Read-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_metadataA
Read-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_eventsA
Read-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_scheduleB
Read-only

Get Exchange Schedule Endpoint for getting the exchange schedule. Calls GET /exchange/schedule.

Inputs: no named parameters.

kalshi_get_exchange_statusA
Read-only

Get Exchange Status Endpoint for getting the exchange status. Calls GET /exchange/status.

Inputs: no named parameters.

kalshi_get_fillsA
Read-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_sportsA
Read-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_programsB
Read-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_marketA
Read-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_candlesticksA
Read-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_eventA
Read-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_orderbookA
Read-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_orderbooksA
Read-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_marketsC
Read-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_milestoneA
Read-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_milestonesC
Read-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_eventsA
Read-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_orderB
Read-only

Get Order Endpoint for getting a single order. Calls GET /portfolio/orders/{order_id}.

Inputs: order_id (required).

kalshi_get_order_queue_positionA
Read-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_positionsA
Read-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_ordersA
Read-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_positionsC
Read-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_seriesA
Read-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_changesC
Read-only

Get Series Fee Changes Calls GET /series/fee_changes.

Inputs: series_ticker, show_historical.

kalshi_get_series_listA
Read-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_settlementsB
Read-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_targetA
Read-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_targetsB
Read-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_balancesA
Read-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_nettingA
Read-only

Get Subaccount Netting Gets the netting enabled settings for all subaccounts. Calls GET /portfolio/subaccounts/netting.

Inputs: no named parameters.

kalshi_get_subaccount_transfersA
Read-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_categoriesA
Read-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_valueA
Read-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_tradesA
Read-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_timestampA
Read-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_withdrawalsA
Read-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

    B3.4/5.0

    Scored across 60 tools

    Disambiguation5/5

    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.

    Naming Consistency4/5

    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.

    Tool Count1/5

    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.

    Completeness5/5

    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

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI assistants to securely trade on Hyperliquid perpetual exchange, including order placement, position management, market data retrieval, and vault operations via natural language.
      23 PyPI
      24
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI assistants like Claude to run backtests, fetch market data, list strategies, and analyze trading algorithms via natural language.
      1,141
      GPL 3.0
    • A
      license
      Not graded
      quality
      C
      maintenance
      MCP 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
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables 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