Skip to content

Markets

Operate on Kalshi markets — the leaf-level YES/NO contracts. List, fetch a single market, pull its orderbook, get candlesticks (single or bulk), list recent trades.

Quick reference

Method Endpoint Auth
list(...) GET /markets no
list_all(...) walks list no
get(ticker) GET /markets/{ticker} no
orderbook(ticker, depth=None) GET /markets/{ticker}/orderbook yes
candlesticks(series_ticker, ticker, *, start_ts, end_ts, period_interval, ...) GET /series/{series_ticker}/markets/{ticker}/candlesticks no
bulk_candlesticks(*, market_tickers, ...) GET /markets/candlesticks no
bulk_orderbooks(*, tickers) GET /markets/orderbooks yes
list_trades(...) GET /markets/trades no
list_all_trades(...) walks list_trades no
create_weather_point_market(...) POST /weather_point_markets yes
weather_point_availability() GET /weather_point_markets/availability no
create_concert_cancellation_market(...) POST /concert_cancellation_markets yes
concert_cancellation_availability(...) GET /concert_cancellation_markets/availability no
list_concerts(*, metro_id, ...) GET /concert_cancellation_markets/concerts yes
search_concerts(*, q) GET /concert_cancellation_markets/concerts/search yes

Orderbook endpoints require auth

orderbook() and bulk_orderbooks() raise AuthRequiredError on an unauthenticated client. The rest of the market-data surface is public.

List markets

page = client.markets.list(
    status="open",                 # MarketStatusLiteral
    series_ticker="KXPRES",
    event_ticker="KXPRES-24",
    tickers=["KXPRES-24-DJT", "KXPRES-24-KH"],  # or "KXPRES-24-DJT,KXPRES-24-KH"
    min_close_ts=1_700_000_000,
    max_close_ts=1_800_000_000,
    mve_filter="exclude",          # MveFilterLiteral
    limit=200,
)
for market in page:
    print(market.ticker, market.yes_bid, market.yes_ask)

tickers accepts a list[str] or a comma-joined string — the SDK comma-joins for the wire (this endpoint uses comma-join form, not the explode form used by bulk_orderbooks).

All eight *_ts filters (min_created_ts, max_created_ts, min_updated_ts, max_updated_ts, min_close_ts, max_close_ts, min_settled_ts, max_settled_ts) are Unix-second ints. max_updated_ts mirrors min_updated_ts: metadata updated no later than that timestamp. It combines with min_updated_ts and mve_filter=exclude the same way.

list_all(...) walks cursors and returns an iterator — see Pagination.

Get one market

market = client.markets.get("KXPRES-24-DJT")
print(market.status, market.yes_bid, market.yes_ask, market.volume)

Orderbook (single)

ob = client.markets.orderbook("KXPRES-24-DJT", depth=20)
print(ob.yes[:5])   # list[OrderbookLevel], best-first
print(ob.no[:5])

depth is the number of price levels per side (default unbounded). Wire keys orderbook_fp.yes_dollars / no_dollars are normalized to ob.yes / ob.no of type Decimal.

Bulk orderbooks

books = client.markets.bulk_orderbooks(tickers=["KXPRES-24-DJT", "KXPRES-24-KH"])
for ob in books:
    print(ob.market_ticker, ob.yes[0])
  • Cap: 100 tickers per call.
  • Wire format: explode (?tickers=a&tickers=b). The SDK builds this for you regardless of whether you pass list[str] or a comma-joined string.
  • Auth required.

Candlesticks

candles = client.markets.candlesticks(
    series_ticker="KXPRES",
    ticker="KXPRES-24-DJT",
    start_ts=1_700_000_000,
    end_ts=1_700_100_000,
    period_interval=60,            # seconds: 60, 3600, 86400
    include_latest_before_start=True,
)
for c in candles:                      # list[Candlestick]
    print(c.end_period_ts, c.yes_bid)

include_latest_before_start includes the most recent candle before start_ts for seamless rendering.

Bulk candlesticks

batches = client.markets.bulk_candlesticks(
    market_tickers=["KXPRES-24-DJT", "KXPRES-24-KH"],   # 1–100 tickers
    start_ts=1_700_000_000,
    end_ts=1_700_100_000,
    period_interval=3600,
)
for batch in batches:                # list[MarketCandlesticks]
    print(batch.market_ticker, len(batch.candlesticks))

Comma-joined wire form (?market_tickers=a,b,c). 100-ticker cap.

List trades

page = client.markets.list_trades(
    ticker="KXPRES-24-DJT",
    min_ts=1_700_000_000,
    max_ts=1_700_100_000,
    is_block_trade=False,   # omit for all trades; True = only block, False = only non-block
    limit=200,
)
for trade in page:
    print(trade.trade_id, trade.taker_side, trade.yes_price, trade.count, trade.is_block_trade)

is_block_trade (SDK v3.1.0; OpenAPI v3.20.0) filters by whether a trade is a block trade. Omit it to return all trades. Each Trade also carries an is_block_trade: bool.

Deprecated since v3.0.0

list_trades_all is the legacy name; it still works but emits DeprecationWarning and will be removed in a future release. Use list_all_trades instead — see #349.

Weather point markets

On-request weather markets for a location, time window, and threshold. Creation is authenticated; availability is public. POST is never retried.

avail = client.markets.weather_point_availability()
print(avail.enabled, [d.name for d in avail.domains])

resp = client.markets.create_weather_point_market(
    latitude=40.785,
    longitude=-73.965,
    variable="precip_hours",       # WeatherPointVariableLiteral
    strike_type="greater",         # "greater" / "less" / "between"
    date="2026-11-11",             # YYYY-MM-DD in timezone
    start_hour=0,
    end_hour=24,
    timezone="America/New_York",
    floor_value=2,
)
print(resp.market_ticker, resp.created, resp.latitude, resp.longitude)

floor_value is required by the server for "greater" and "between"; cap_value for "less" and "between". The SDK does not enforce that — unset optional fields are omitted from the wire body. The same request always returns the same market; created is false when it already existed. The response coordinates are the snapped NOAA MRMS grid-cell center.

Concert cancellation markets

On-request markets on whether a concert is called off. Creation, listing, and search are authenticated; availability is public. POST is never retried.

avail = client.markets.concert_cancellation_availability()
print(avail.enabled, avail.covers, avail.max_days_ahead)
print([m.name for m in avail.metros])

page = client.markets.list_concerts(metro_id=avail.metros[0].id)
show = page.concerts[0]

hits = client.markets.search_concerts(q="Madison Square")

resp = client.markets.create_concert_cancellation_market(
    jambase_event_id=show.jambase_event_id,
    scheduled_date=show.scheduled_date,  # YYYY-MM-DD
    cover="postponed",                   # ConcertCoverLiteral: "postponed" / "cancelled" / "either"
)
print(resp.market_ticker, resp.created, resp.cover)

Take jambase_event_id and scheduled_date from list_concerts or search_concerts. A cover missing from avail.covers cannot be created. The same request always returns the same market; created is false when it already existed. Pass the returned market_ticker to POST /communications/rfqs. list_concerts is paged by the server (page / total_pages); there is no SDK paginator.

Reference

kalshi.resources.markets.MarketsResource

MarketsResource(transport: SyncTransport)

Bases: SyncResource

Sync markets API.

list_trades_all

list_trades_all(
    *,
    ticker: str | None = None,
    min_ts: int | None = None,
    max_ts: int | None = None,
    limit: int | None = None,
    is_block_trade: bool | None = None,
    max_pages: int | None = None,
    extra_headers: dict[str, str] | None = None
) -> Iterator[Trade]

.. deprecated:: 3.0.0 Use :meth:list_all_trades instead.

bulk_candlesticks

bulk_candlesticks(
    *,
    market_tickers: list[str] | str,
    start_ts: int,
    end_ts: int,
    period_interval: int,
    include_latest_before_start: bool | None = None,
    extra_headers: dict[str, str] | None = None
) -> builtins.list[MarketCandlesticks]

Fetch candlesticks for up to 100 markets in a single call.

market_tickers serializes as a comma-separated string per spec (not exploded). Accepts a list, tuple, or pre-joined string. Spec requires at least one ticker (max 100).

bulk_orderbooks

bulk_orderbooks(
    *,
    tickers: list[str],
    extra_headers: dict[str, str] | None = None
) -> builtins.list[Orderbook]

Fetch orderbooks for up to 100 tickers in a single call.

Spec requires auth and at least one ticker (max 100). tickers wire format is ?tickers=a&tickers=b (spec style: form, explode: true) — httpx serializes list values that way by default.

create_weather_point_market

create_weather_point_market(
    *,
    request: CreateWeatherPointMarketRequest,
    extra_headers: dict[str, str] | None = None
) -> CreateWeatherPointMarketResponse
create_weather_point_market(
    *,
    latitude: float,
    longitude: float,
    variable: WeatherPointVariableLiteral,
    strike_type: Literal["greater", "less", "between"],
    date: str,
    start_hour: int,
    end_hour: int,
    timezone: str,
    floor_value: int | None = ...,
    cap_value: int | None = ...,
    extra_headers: dict[str, str] | None = None
) -> CreateWeatherPointMarketResponse
create_weather_point_market(
    *,
    request: CreateWeatherPointMarketRequest | None = None,
    latitude: float | None = None,
    longitude: float | None = None,
    variable: WeatherPointVariableLiteral | None = None,
    strike_type: (
        Literal["greater", "less", "between"] | None
    ) = None,
    date: str | None = None,
    start_hour: int | None = None,
    end_hour: int | None = None,
    timezone: str | None = None,
    floor_value: int | None = None,
    cap_value: int | None = None,
    extra_headers: dict[str, str] | None = None
) -> CreateWeatherPointMarketResponse

POST /weather_point_markets. Not retried.

Returns the on-request weather market for a location, time window and threshold, creating it if it does not exist. created is false when a market for the same request already existed.

weather_point_availability

weather_point_availability(
    *, extra_headers: dict[str, str] | None = None
) -> GetWeatherPointAvailabilityResponse

GET /weather_point_markets/availability. Public.

create_concert_cancellation_market

create_concert_cancellation_market(
    *,
    request: CreateConcertCancellationMarketRequest,
    extra_headers: dict[str, str] | None = None
) -> CreateConcertCancellationMarketResponse
create_concert_cancellation_market(
    *,
    jambase_event_id: str,
    scheduled_date: str,
    cover: ConcertCoverLiteral,
    extra_headers: dict[str, str] | None = None
) -> CreateConcertCancellationMarketResponse
create_concert_cancellation_market(
    *,
    request: (
        CreateConcertCancellationMarketRequest | None
    ) = None,
    jambase_event_id: str | None = None,
    scheduled_date: str | None = None,
    cover: ConcertCoverLiteral | None = None,
    extra_headers: dict[str, str] | None = None
) -> CreateConcertCancellationMarketResponse

POST /concert_cancellation_markets. Not retried.

Returns the on-request concert cancellation market for a show, date and cover, creating it if it does not exist. created is false when a market for the same request already existed.

concert_cancellation_availability

concert_cancellation_availability(
    *,
    date_from: str | None = None,
    date_to: str | None = None,
    extra_headers: dict[str, str] | None = None
) -> GetConcertCancellationAvailabilityResponse

GET /concert_cancellation_markets/availability. Public.

list_concerts

list_concerts(
    *,
    metro_id: str,
    date_from: str | None = None,
    date_to: str | None = None,
    page: int | None = None,
    extra_headers: dict[str, str] | None = None
) -> GetConcertsResponse

GET /concert_cancellation_markets/concerts. Authenticated.

search_concerts

search_concerts(
    *, q: str, extra_headers: dict[str, str] | None = None
) -> SearchConcertsResponse

GET /concert_cancellation_markets/concerts/search. Authenticated.

kalshi.resources.markets.AsyncMarketsResource

AsyncMarketsResource(transport: AsyncTransport)

Bases: AsyncResource

Async markets API.

list_all

list_all(
    *,
    status: MarketStatusLiteral | None = None,
    series_ticker: str | None = None,
    event_ticker: str | None = None,
    tickers: list[str] | str | None = None,
    mve_filter: MveFilterLiteral | None = None,
    min_created_ts: int | None = None,
    max_created_ts: int | None = None,
    min_updated_ts: int | None = None,
    max_updated_ts: int | None = None,
    min_close_ts: int | None = None,
    max_close_ts: int | None = None,
    min_settled_ts: int | None = None,
    max_settled_ts: int | None = None,
    limit: int | None = None,
    max_pages: int | None = None,
    extra_headers: dict[str, str] | None = None
) -> AsyncIterator[Market]

Returns an async iterator — use async for.

list_all_trades

list_all_trades(
    *,
    ticker: str | None = None,
    min_ts: int | None = None,
    max_ts: int | None = None,
    limit: int | None = None,
    is_block_trade: bool | None = None,
    max_pages: int | None = None,
    extra_headers: dict[str, str] | None = None
) -> AsyncIterator[Trade]

Returns an async iterator — use async for.

list_trades_all

list_trades_all(
    *,
    ticker: str | None = None,
    min_ts: int | None = None,
    max_ts: int | None = None,
    limit: int | None = None,
    is_block_trade: bool | None = None,
    max_pages: int | None = None,
    extra_headers: dict[str, str] | None = None
) -> AsyncIterator[Trade]

.. deprecated:: 3.0.0 Use :meth:list_all_trades instead.

bulk_candlesticks async

bulk_candlesticks(
    *,
    market_tickers: list[str] | str,
    start_ts: int,
    end_ts: int,
    period_interval: int,
    include_latest_before_start: bool | None = None,
    extra_headers: dict[str, str] | None = None
) -> builtins.list[MarketCandlesticks]

Fetch candlesticks for up to 100 markets in a single call.

market_tickers serializes as a comma-separated string per spec (not exploded). Accepts a list, tuple, or pre-joined string. Spec requires at least one ticker (max 100).

bulk_orderbooks async

bulk_orderbooks(
    *,
    tickers: list[str],
    extra_headers: dict[str, str] | None = None
) -> builtins.list[Orderbook]

Fetch orderbooks for up to 100 tickers in a single call.

Spec requires auth and at least one ticker (max 100). tickers wire format is ?tickers=a&tickers=b (spec style: form, explode: true) — httpx serializes list values that way by default.

create_weather_point_market async

create_weather_point_market(
    *,
    request: CreateWeatherPointMarketRequest,
    extra_headers: dict[str, str] | None = None
) -> CreateWeatherPointMarketResponse
create_weather_point_market(
    *,
    latitude: float,
    longitude: float,
    variable: WeatherPointVariableLiteral,
    strike_type: Literal["greater", "less", "between"],
    date: str,
    start_hour: int,
    end_hour: int,
    timezone: str,
    floor_value: int | None = ...,
    cap_value: int | None = ...,
    extra_headers: dict[str, str] | None = None
) -> CreateWeatherPointMarketResponse
create_weather_point_market(
    *,
    request: CreateWeatherPointMarketRequest | None = None,
    latitude: float | None = None,
    longitude: float | None = None,
    variable: WeatherPointVariableLiteral | None = None,
    strike_type: (
        Literal["greater", "less", "between"] | None
    ) = None,
    date: str | None = None,
    start_hour: int | None = None,
    end_hour: int | None = None,
    timezone: str | None = None,
    floor_value: int | None = None,
    cap_value: int | None = None,
    extra_headers: dict[str, str] | None = None
) -> CreateWeatherPointMarketResponse

Async :meth:MarketsResource.create_weather_point_market.

weather_point_availability async

weather_point_availability(
    *, extra_headers: dict[str, str] | None = None
) -> GetWeatherPointAvailabilityResponse

Async :meth:MarketsResource.weather_point_availability.

create_concert_cancellation_market async

create_concert_cancellation_market(
    *,
    request: CreateConcertCancellationMarketRequest,
    extra_headers: dict[str, str] | None = None
) -> CreateConcertCancellationMarketResponse
create_concert_cancellation_market(
    *,
    jambase_event_id: str,
    scheduled_date: str,
    cover: ConcertCoverLiteral,
    extra_headers: dict[str, str] | None = None
) -> CreateConcertCancellationMarketResponse
create_concert_cancellation_market(
    *,
    request: (
        CreateConcertCancellationMarketRequest | None
    ) = None,
    jambase_event_id: str | None = None,
    scheduled_date: str | None = None,
    cover: ConcertCoverLiteral | None = None,
    extra_headers: dict[str, str] | None = None
) -> CreateConcertCancellationMarketResponse

Async :meth:MarketsResource.create_concert_cancellation_market.

concert_cancellation_availability async

concert_cancellation_availability(
    *,
    date_from: str | None = None,
    date_to: str | None = None,
    extra_headers: dict[str, str] | None = None
) -> GetConcertCancellationAvailabilityResponse

Async :meth:MarketsResource.concert_cancellation_availability.

list_concerts async

list_concerts(
    *,
    metro_id: str,
    date_from: str | None = None,
    date_to: str | None = None,
    page: int | None = None,
    extra_headers: dict[str, str] | None = None
) -> GetConcertsResponse

Async :meth:MarketsResource.list_concerts.

search_concerts async

search_concerts(
    *, q: str, extra_headers: dict[str, str] | None = None
) -> SearchConcertsResponse

Async :meth:MarketsResource.search_concerts.