Kalshi RFQ API (2026): Request for Quote and Block Trades
The Short Answer
Kalshi's RFQ API lets you ask market makers for a private price on a specific market and size, instead of working an order through the public book. You create a request for quote with POST /communications/rfqs, makers answer with quotes carrying a YES price and a NO price for the full size, you accept one side of the best quote, and the maker confirms within 30 seconds, or 3 on high-volatility markets such as combos. After a short execution timer, both orders are entered on the book. The same flow runs over REST, FIX and WebSocket. Before you accept a quote, Predictefy shows where the same outcome trades on 15+ other venues, so you can judge the price you are being offered.
Key Takeaways
- An RFQ names a market ticker and a size, in contracts or as a dollar target, and you can hold up to 100 open RFQs at a time.
- Quotes carry a
yes_bidand ano_bidfor the full size, stay private to each maker, and are rejected if the two sum to more than $1. - Execution is a two-step lock: the requester accepts one side, then the maker confirms.
- Confirmation windows are 30 seconds, or 3 on high-volatility markets, followed by a 15 or 1 second execution timer.
- Quote events arrive on the authenticated
communicationsWebSocket channel, not the order book channel. - Judge a quote against the wider market: Predictefy shows the same outcome's order books across 15+ venues through one API key.
What is Kalshi's RFQ API?
RFQ stands for request for quote. It is Kalshi's system for pre-execution communication between members: a requester asks for a price on a specific market and size, and market makers compete to fill it. It is useful whenever the public book is the wrong place for a trade, for example a size larger than the displayed depth, a thin market, or a combo that has no standing book at all.
RFQs work on any Kalshi market, including combo markets, which Kalshi builds from multiple legs and calls multivariate events. The system is available over three interfaces: REST under /communications, FIX, and WebSocket, where quote notifications arrive on the communications channel.
How does a Kalshi RFQ work step by step?
- The requester creates an RFQ naming a market, a size and whether to rest any remainder.
- Kalshi broadcasts the RFQ to all makers.
- Makers answer with quotes containing a
yes_bidand ano_bidfor the full size. Each quote is private between the requester and that maker. - The requester accepts one side of the best-priced quote.
- The maker confirms within the confirmation window. Once confirmed, neither party can withdraw.
- When the execution timer ends, the orders are entered on the public book, and the fills appear in your portfolio.
How do you create an RFQ?
With POST /communications/rfqs. The official Python SDK takes the request fields as keyword arguments:
from kalshi_python_sync import Configuration, KalshiClient
config = Configuration(host="https://external-api.kalshi.com/trade-api/v2")
config.api_key_id = "YOUR_API_KEY_ID"
with open("kalshi-private-key.pem") as f:
config.private_key_pem = f.read()
client = KalshiClient(config)
rfq = client.create_rfq(market_ticker="MARKET_TICKER", contracts_fp="500", rest_remainder=False)
print(rfq.id)The response carries the RFQ's UUID, which every later call needs. Size the request with exactly one of contracts_fp, a contract count with up to two decimals, or target_cost_dollars, a dollar amount to spend. Authentication is the usual Kalshi API key and RSA signing, covered in the Kalshi SDK guide.
| Field | What it does |
|---|---|
market_ticker | The market to quote. Required |
contracts_fp | Size as a contract count, in 0.01-contract steps |
target_cost_dollars | Size as a dollar amount; Kalshi derives the count from the quoted price |
target_cost_excludes_fees | Treat the target as principal only, with the taker fee charged on top |
rest_remainder | Whether any unfilled remainder rests on the book after execution. Required |
replace_existing | Delete your existing RFQs as part of creating this one |
subaccount | Create the RFQ under a numbered subaccount, 1 to 63 |
Two limits are worth knowing. You can hold at most 100 open RFQs, and only one open RFQ per market, so a second request on the same ticker returns a 409 conflict unless you set replace_existing. By default a dollar target caps principal plus Kalshi's fees, so your debit never exceeds it; contract-sized RFQs are never reduced for fees.
How do market makers quote an RFQ?
With POST /communications/quotes, naming the RFQ and two prices:
quote = client.create_quote(rfq_id="RFQ_ID", yes_bid="0.41", no_bid="0.55", rest_remainder=False)
print(quote.id)yes_bid is the price per YES contract and no_bid the price per NO contract. Either can be "0" to decline that side, but not both, and a quote where the two sum to more than $1 is rejected. Quotes carry no size of their own: each one is for the full RFQ amount. Prices must sit on the market's price grid, listed under price_ranges on GET /markets/{ticker}, and a new quote on the same RFQ replaces the maker's previous one. With post_only, the maker's resting order is cancelled rather than crossing the book if it would take liquidity.
How do you accept and confirm a quote?
The requester accepts one side, then the maker confirms:
quotes = client.get_quotes(rfq_id="RFQ_ID")
client.accept_rfq_quote("RFQ_ID", "QUOTE_ID", accepted_side="yes") # requester
client.confirm_rfq_quote("RFQ_ID", "QUOTE_ID") # makerAccepting starts the maker's confirmation window, and confirming starts the execution timer. When the timer ends, the orders are entered on the book and the fills appear in GET /portfolio/fills, where makers match them on creator_order_id and requesters on rfq_creator_order_id.
| Standard markets | High-volatility markets | |
|---|---|---|
| Confirmation window | 30 seconds | 3 seconds |
| Execution timer | 15 seconds | 1 second |
Kalshi designates some markets as high-volatility, and every combo market is one of them. On those, a maker has three seconds to confirm, which in practice means automated quoting rather than a person at a keyboard.
How do you follow RFQs in real time?
Subscribe to the communications WebSocket channel, which requires authentication. rfq_created and rfq_deleted go to every subscriber, which is how makers see new requests. quote_created, quote_accepted and quote_executed go only to the requester and maker involved. Kalshi's WebSocket setup and limits are covered in the Kalshi WebSocket API.
How do RFQs work for combos and block trades?
Combos. A combo RFQ adds mve_collection_ticker and mve_selected_legs to describe the legs, and eligible combinations are discovered through Kalshi's multivariate event collections. Combo pricing from the trader's side is covered in Kalshi combos.
Block trades. A block trade is a pre-arranged trade between two named members. The proposal names the buyer and seller, the market, the price, the size, the maker side and an expiry, and the counterparty accepts it through its own endpoint. Proposals are listed with GET on the block trade proposals route.
What errors should an RFQ integration handle?
| Error | Meaning |
|---|---|
invalid_parameters | A price off the valid step, or an RFQ that is already closed |
RFQ_CLOSED | The RFQ was deleted, expired or already executed |
INSUFFICIENT_BALANCE | Not enough funds for the trade |
409 Conflict | An open RFQ already exists on that market |
How do you judge whether a quote is good?
Compare it with the market you could otherwise trade. Kalshi's own book is the first reference, read through the Kalshi order book API. The second is every other venue listing the same question. Predictefy returns Kalshi's order book alongside Polymarket's and 15+ other venues in one normalized shape through one API key, so a requester can see at a glance whether a quote beats what the wider market would pay.
Frequently Asked Questions
What is the Kalshi RFQ API?
It is Kalshi's request-for-quote system for pre-execution communication between members. A requester asks for a price on a specific market and size, market makers answer with private quotes, and the requester accepts the best one. It works on any market, including combos, and is available over REST, FIX and WebSocket.
How long does a Kalshi maker have to confirm a quote?
Thirty seconds on standard markets and three seconds on high-volatility markets, which include every combo. Once the maker confirms, neither side can withdraw, and an execution timer of 15 seconds, or one second on high-volatility markets, runs before the orders are entered on the book.
Can you use RFQs on Kalshi combos?
Yes. A combo RFQ includes mve_collection_ticker and mve_selected_legs to describe the legs, and eligible combinations come from Kalshi's multivariate event collections. All combo markets are classed as high-volatility, so they use the shorter three-second confirmation window and one-second execution timer.
Are Kalshi RFQ quotes visible to other traders?
No. Each quote is private between the requester and the maker who sent it, and makers cannot see each other's quotes. New RFQs are broadcast to every subscriber of the communications channel, but quote creation, acceptance and execution events go only to the two parties involved.
How do fees work on a Kalshi RFQ?
The requester pays Kalshi's taker fee. When an RFQ is sized by target_cost_dollars, the target caps principal plus that fee by default, so the debit never exceeds it; setting target_cost_excludes_fees charges the fee on top instead. RFQs sized in contracts are never reduced for fees.
How do you know if a Kalshi RFQ quote is a good price?
Compare it with the prices you could get elsewhere. Kalshi's own order book is the first reference, and the same question often trades on other venues too. Predictefy returns Kalshi's order book alongside Polymarket's and 15+ other venues in one normalized shape through one API key, so a quote can be judged against the wider market.