Kalshi API Documentation

https://docs.kalshi.com
Admin
Kalshi's trader and developer documentation outlines exchange functionality, market details, and API...
Tokens:530,071
Snippets:3,344
Trust Score:9.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Complete Working Example: Get Balance

Source: https://docs.kalshi.com/getting_started/quick_start_authenticated_requests

Complete minimal example to get the account balance. Includes loading the private key, creating the signature with PSS padding, and making an authenticated GET request. Configure API_KEY_ID, PRIVATE_KEY_PATH, and BASE_URL (demo or production) before running.

```python
import requests
import datetime
import base64
from urllib.parse import urlparse
from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives.asymmetric import padding

# Configuration
API_KEY_ID = 'your-api-key-id-here'
PRIVATE_KEY_PATH = 'path/to/your/kalshi-key.key'
BASE_URL = 'https://external-api.demo.kalshi.co/trade-api/v2'  # or 'https://external-api.kalshi.com/trade-api/v2' for production

def load_private_key(key_path):
    with open(key_path, "rb") as f:
        return serialization.load_pem_private_key(f.read(), password=None, backend=default_backend())

def create_signature(private_key, timestamp, method, path):
    """Create the request signature."""
    # Strip query parameters before signing
    path_without_query = path.split('?')[0]
    message = f"{timestamp}{method}{path_without_query}".encode('utf-8')
    signature = private_key.sign(
        message,
        padding.PSS(mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.DIGEST_LENGTH),
        hashes.SHA256()
    )
    return base64.b64encode(signature).decode('utf-8')

def get(private_key, api_key_id, path, base_url=BASE_URL):
    """Make an authenticated GET request to the Kalshi API."""
    timestamp = str(int(datetime.datetime.now().timestamp() * 1000))
    # Signing requires the full URL path from root (e.g. /trade-api/v2/portfolio/balance)
    sign_path = urlparse(base_url + path).path
    signature = create_signature(private_key, timestamp, "GET", sign_path)

    headers = {
        'KALSHI-ACCESS-KEY': api_key_id,
        'KALSHI-ACCESS-SIGNATURE': signature,
        'KALSHI-ACCESS-TIMESTAMP': timestamp
    }

    return requests.get(base_url + path, headers=headers)

# Load private key
private_key = load_private_key(PRIVATE_KEY_PATH)

# Get balance
response = get(private_key, API_KEY_ID, "/portfolio/balance")
print(f"Your balance: ${response.json()['balance'] / 100:.2f}")
```

--------------------------------

### Get open markets for KXHIGHNY series and event details (Python)

Source: https://docs.kalshi.com/getting_started/quick_start_market_data

Python example using the Kalshi API to fetch open markets for the KXHIGHNY series and then get details for the first market's event. Uses the external-api.kalshi.com endpoints for markets and events.

```python
# Get all open markets for the KXHIGHNY series
markets_url = f"https://external-api.kalshi.com/trade-api/v2/markets?series_ticker=KXHIGHNY&status=open"
markets_response = requests.get(markets_url)
markets_data = markets_response.json()

print(f"\nActive markets in KXHIGHNY series:")
for market in markets_data['markets']:
    print(f"- {market['ticker']}: {market['title']}")
    print(f"  Event: {market['event_ticker']}")
    print(f"  Yes Price: ${market['yes_bid_dollars']} | Volume: {market['volume_fp']}")
    print()

# Get details for a specific event if you have its ticker
if markets_data['markets']:
    # Let's get details for the first market's event
    event_ticker = markets_data['markets'][0]['event_ticker']
    event_url = f"https://external-api.kalshi.com/trade-api/v2/events/{event_ticker}"
    event_response = requests.get(event_url)
    event_data = event_response.json()

    print(f"Event Details:")
    print(f"Title: {event_data['event']['title']}")
    print(f"Category: {event_data['event']['category']}")
```

--------------------------------

### Get open markets for KXHIGHNY series and event details (JavaScript)

Source: https://docs.kalshi.com/getting_started/quick_start_market_data

JavaScript example using the Kalshi API to fetch open markets for the KXHIGHNY series and then get details for the first market's event. Uses the external-api.kalshi.com endpoints for markets and events.

```javascript
// Get markets for the KXHIGHNY series
async function getSeriesMarkets() {
  // Get all open markets for this series
  const marketsResponse = await fetch('https://external-api.kalshi.com/trade-api/v2/markets?series_ticker=KXHIGHNY&status=open');
  const marketsData = await marketsResponse.json();

  console.log('\nActive markets in KXHIGHNY series:');
  marketsData.markets.forEach(market => {
    console.log(`- ${market.ticker}: ${market.title}`);
    console.log(`  Event: ${market.event_ticker}`);
    console.log(`  Yes Price: $${market.yes_bid_dollars} | Volume: ${market.volume_fp}`);
    console.log();
  });

  // Get details for a specific event if markets exist
  if (marketsData.markets.length > 0) {
    const eventTicker = marketsData.markets[0].event_ticker;
    const eventResponse = await fetch(`https://external-api.kalshi.com/trade-api/v2/events/${eventTicker}`);
    const eventData = await eventResponse.json();

    console.log('Event Details:');
    console.log(`Title: ${eventData.event.title}`);
    console.log(`Category: ${eventData.event.category}`);
  }
}

getSeriesMarkets();
```

--------------------------------

### Example Request for Get Market Orderbook

Source: https://docs.kalshi.com/getting_started/orderbook_responses

These examples fetch the orderbook for a specific market using the external API. The Python example uses the requests library, the JavaScript example uses fetch, and the cURL example uses a direct GET request. All use the market ticker KXHIGHNY-24JAN01-T60.

```python
import requests

# Get orderbook for a specific market
market_ticker = "KXHIGHNY-24JAN01-T60"
url = f"https://external-api.kalshi.com/trade-api/v2/markets/{market_ticker}/orderbook"

response = requests.get(url)
orderbook_data = response.json()
```

```javascript
// Get orderbook for a specific market
const marketTicker = "KXHIGHNY-24JAN01-T60";
const url = `https://external-api.kalshi.com/trade-api/v2/markets/${marketTicker}/orderbook`;

fetch(url)
  .then(response => response.json())
  .then(data => console.log(data));
```

```curl
curl -X GET "https://external-api.kalshi.com/trade-api/v2/markets/KXHIGHNY-24JAN01-T60/orderbook"
```

--------------------------------

### Example Response for Get Market Orderbook

Source: https://docs.kalshi.com/getting_started/orderbook_responses

Example response from the Get Market Orderbook endpoint. The response is wrapped in an orderbook_fp object containing yes_dollars and no_dollars arrays. Each bid is a two-element string array: [price_dollars, count_fp]. Both values are strings to support subpenny pricing and fractional contract sizes.

```json
{
  "orderbook_fp": {
    "yes_dollars": [
      ["0.0100", "200.00"],
      ["0.1500", "100.00"],
      ["0.2000", "50.00"],
      ["0.2500", "20.00"],
      ["0.3000", "11.00"],
      ["0.3100", "10.00"],
      ["0.3200", "10.00"],
      ["0.3300", "11.00"],
      ["0.3400", "9.00"],
      ["0.3500", "11.00"],
      ["0.4100", "10.00"],
      ["0.4200", "12.00"]
    ],
    "no_dollars": [
      ["0.0100", "100.00"],
      ["0.1600", "3.00"],
      ["0.2500", "50.00"],
      ["0.2800", "19.00"],
      ["0.3600", "5.00"],
      ["0.3700", "50.00"],
      ["0.3800", "300.00"],
      ["0.4400", "29.00"],
      ["0.4500", "20.00"],
      ["0.5600", "17.00"]
    ]
  }
}
```

--------------------------------

### GET /events

Source: https://docs.kalshi.com/openapi.yaml

Get all events. This endpoint excludes multivariate events. Use the GET /events/multivariate endpoint for those. All events are accessible, even if their markets are older than the historical cutoff.

```APIDOC
## GET /events

### Description
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.

### Method
GET

### Endpoint
/events

### Parameters
#### Query Parameters
- **limit** (integer) - Optional - Parameter to specify the number of results per page. Defaults to 200. Maximum value is 200.
- **cursor** (string) - Optional - Parameter to specify the pagination cursor. Use the cursor value returned from the previous response to get the next page of results. Leave empty for the first page.
- **with_nested_markets** (boolean) - Optional - Parameter to specify if nested markets should be included in the response. When true, each event will include a 'markets' field containing a list of Market objects associated with that event. Historical markets settled before the historical cutoff will not be included.
- **with_milestones** (boolean) - Optional - If true, includes related milestones as a field alongside events.
- **status** (string) - Optional - Filter by event status. Possible values are 'unopened', 'open', 'closed', 'settled'. Leave empty to return events with any status.
- **series_ticker** (string) - Optional - Filter by series ticker (referenced from components).
- **event_tickers** (string) - Optional - Filter by event tickers (referenced from components).
- **min_close_ts** (integer) - Optional - Filter events with at least one market with close timestamp greater than this Unix timestamp (in seconds).
- **min_updated_ts** (integer) - Optional - Filter events with metadata updated after this Unix timestamp (in seconds). Use this to efficiently poll for changes.

### Response
#### Success Response (200)
Events retrieved successfully

#### Response Example
{
  "events": [
    {
      "event_ticker": "string",
      "title": "string",
      "status": "string",
      "markets": [
        {
          "ticker": "string",
          "title": "string"
        }
      ]
    }
  ],
  "cursor": "string"
}

#### Error Responses
- **400** - Bad request
- **401** - Unauthorized
- **500** - Internal server error
```

--------------------------------

### GET /communications/block-trade-proposals

Source: https://docs.kalshi.com/openapi.yaml

Retrieves block trade proposals visible to the authenticated user.

```APIDOC
## GET /communications/block-trade-proposals

### Description
Endpoint for getting block trade proposals visible to the authenticated user.

### Method
GET

### Endpoint
/communications/block-trade-proposals

### Parameters
#### Query Parameters
- **cursor** (string) - Optional - Pagination cursor
- **ticker** (string) - Optional - Market ticker filter
- **limit** (integer) - Optional - Number of results per page, defaults to 100, min 1, max 100
- **status** (string) - Optional - Filter by status

### Response
#### Success Response (200)
- **proposals** (array) - List of block trade proposals

#### Response Example
{
  "proposals": []
}

#### Error Responses
- **400** - Bad request
- **401** - Unauthorized
- **500** - Internal server error
```

--------------------------------

### GET /historical/orders

Source: https://docs.kalshi.com/openapi.yaml

Retrieves orders that have been archived to the historical database. Requires authentication via Kalshi API keys.

```APIDOC
## GET /historical/orders

### Description
Gets orders that have been archived to the historical database.

### Method
GET

### Endpoint
/historical/orders

### Authentication
- Requires Kalshi API access key, signature, and timestamp.

### Parameters
#### Query Parameters
- **ticker** (string): Optional - Filter by market ticker.
- **max_ts** (integer): Optional - Maximum timestamp.
- **limit** (integer): Optional - Limit the number of results.
- **cursor** (string): Optional - Cursor for pagination.

### Response
#### Success Response (200)
Historical orders retrieved successfully.

#### Error Responses
- 400: Bad request
- 401: Unauthorized
- 500: Internal server error
```

--------------------------------

### GET /portfolio/orders

Source: https://docs.kalshi.com/openapi.yaml

Retrieves orders from the user's portfolio with optional filters. Requires authentication and supports filtering by status, ticker, timestamps, and pagination.

```APIDOC
## [GET] /portfolio/orders

### Description
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](https://docs.kalshi.com/getting_started/historical_data) for details.

### Method
GET

### Endpoint
/portfolio/orders

### Parameters
#### Query Parameters
- **ticker** (string) - Optional - Filter by market ticker
- **event_ticker** (string) - Optional - Filter by event ticker
- **min_ts** (integer) - Optional - Minimum timestamp
- **max_ts** (integer) - Optional - Maximum timestamp
- **status** (string) - Optional - Order status filter
- **limit** (integer) - Optional - Maximum number of orders to return
- **cursor** (string) - Optional - Pagination cursor
- **subaccount** (string) - Optional - Subaccount filter
- **exchange_index** (string) - Optional - Exchange index filter

### Response
#### Success Response (200)
Orders retrieved successfully

#### Error Responses
- **400** - Bad request
- **401** - Unauthorized
- **500** - Internal server error
```

--------------------------------

### GET /historical/fills

Source: https://docs.kalshi.com/openapi.yaml

Retrieves all historical fills for the member. A fill is when a trade you have is matched. Requires authentication via Kalshi API keys.

```APIDOC
## GET /historical/fills

### Description
Gets all historical fills for the member. A fill is when a trade you have is matched.

### Method
GET

### Endpoint
/historical/fills

### Authentication
Requires Kalshi API credentials: access key, signature, and timestamp.

### Parameters
#### Query Parameters
- **ticker** (string) - Optional - Filter by market ticker.
- **max_ts** (integer) - Optional - Maximum timestamp.
- **limit** (integer) - Optional - Limit the number of results.
- **cursor** (string) - Optional - Cursor for pagination.

### Response
#### Success Response (200)
Fills retrieved successfully.

#### Error Responses
- 400: Bad request
- 401: Unauthorized
- 404: Not found
- 500: Internal server error
```

--------------------------------

### GET /api_keys

Source: https://docs.kalshi.com/openapi.yaml

Retrieves all API keys associated with the authenticated user. Optionally filters by FCM subtrader ID.

```APIDOC
## GET /api_keys

### Description
Retrieves all API keys associated with the authenticated user. Optionally filters by FCM subtrader ID.

### Method
GET

### Endpoint
/api_keys

### Parameters
#### Query Parameters
- **fcm_subtrader_id** (string) - Optional - Return only API keys bound to this FCM subtrader. Spelled {your_user_id}_{suffix}; only FCM members hold bound keys. Omit to return every key.

### Response
#### Success Response (200)
List of API keys retrieved successfully

#### Error Responses
- **401** - Unauthorized
- **500** - Internal server error
```

--------------------------------

### GET /markets/orderbooks

Source: https://docs.kalshi.com/openapi.yaml

Retrieves the current order books for multiple markets in a single request. Returns one orderbook per requested market ticker. Requires authentication.

```APIDOC
## GET /markets/orderbooks

### Description
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 quantities and order counts, organized from best to worst prices. Returns one orderbook per requested market ticker.

### Method
GET

### Endpoint
/markets/orderbooks

### Parameters
#### Query Parameters
- **tickers** (array of strings) - Required - List of market tickers to fetch orderbooks for. Minimum items: 1, Maximum items: 100. Each item max length: 200.

### Response
#### Success Response (200)
Orderbooks retrieved successfully.

#### Error Responses
- **400** - Bad Request
- **401** - Unauthorized
- **500** - Internal Server Error

### Authentication
Requires kalshiAccessKey, kalshiAccessSignature, and kalshiAccessTimestamp headers.
```

--------------------------------

### GET /markets/candlesticks

Source: https://docs.kalshi.com/openapi.yaml

Retrieves candlestick data for multiple markets. Accepts up to 100 market tickers per request and returns up to 10,000 candlesticks total, grouped by market_id.

```APIDOC
## GET /markets/candlesticks

### Description
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, and groups candlesticks by market_id. Optionally includes a synthetic initial candlestick for price continuity.

### Method
GET

### Endpoint
/markets/candlesticks

### Parameters
#### Query Parameters
- **market_tickers** (string) - Required - Comma-separated list of market tickers (maximum 100).
- **start_ts** (integer) - Required - Start timestamp in Unix seconds.
- **end_ts** (integer) - Required - End timestamp in Unix seconds.
- **period_interval** (integer) - Required - Candlestick period interval in minutes (minimum 1).
- **include_latest_before_start** (boolean) - Optional - If true, prepends the latest candlestick available before the start_ts. This synthetic candlestick is created by: 1. Finding the most recent real candlestick before start_ts, 2. Projecting it forward to the first period boundary (calculated as the next period interval after start_ts), 3. Setting all OHLC prices to null, and `previous_price` to the close price from the real candlestick. Default: false.

### Response
#### Success Response (200)
- **Candlesticks** - Candlestick data grouped by market_id.

#### Response Example
```json
{
  "candlesticks": {
    "MARKET-1": [
      {
        "start_ts": 1609459200,
        "open": 50,
        "high": 55,
        "low": 45,
        "close": 52,
        "volume": 100
      }
    ]
  }
}
```

#### Error Responses
- **400** - Bad request
- **401** - Unauthorized
- **500** - Internal server error
```

--------------------------------

### GET /series/{series_ticker}/markets/{ticker}/candlesticks

Source: https://docs.kalshi.com/openapi.yaml

Retrieves candlestick data for a specific market within a series. The `period_interval` parameter specifies the duration of each candlestick (1 minute, 1 hour, or 1 day). For markets settled before the historical cutoff, use the historical endpoint.

```APIDOC
## [GET] /series/{series_ticker}/markets/{ticker}/candlesticks

### Description
Retrieves candlestick data for a specific market. 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](https://docs.kalshi.com/getting_started/historical_data) for details.

### Method
GET

### Endpoint
/series/{series_ticker}/markets/{ticker}/candlesticks

### Parameters
#### Path Parameters
- **series_ticker** (string) - Required - Series ticker - the series that contains the target market
- **ticker** (string) - Required - Market ticker - unique identifier for the specific market

#### Query Parameters
- **start_ts** (integer) - Required - Start timestamp (Unix timestamp). Candlesticks will include those ending on or after this time.
- **end_ts** (integer) - Required - End timestamp (Unix timestamp). Candlesticks will include those ending on or before this time.
- **period_interval** (integer) - Required - Time period length of each candlestick in minutes. Valid values are 1 (1 minute), 60 (1 hour), or 1440 (1 day).
- **include_latest_before_start** (boolean) - Optional - If true, prepends the latest candlestick available before the start_ts. This synthetic candlestick is created by: 1. Finding the most recent real candlestick before start_ts; 2. Projecting it forward to the first period boundary (calculated as the next period interval after start_ts); 3. Setting all OHLC prices to null, and previous_price to the close price from the real candlestick

### Response
#### Success Response (200)
Candlesticks retrieved successfully

#### Error Responses
- **400**: Bad request
- **404**: Not found
- **500**: Internal server error
```

--------------------------------

### Command Examples

Source: https://docs.kalshi.com/asyncapi.yaml

All command examples from the AsyncAPI specification, including subscribe, unsubscribe, and list_subscriptions commands.

```yaml
id: 1
cmd: subscribe
params:
  channels: ["orderbook_delta"]
  market_ticker: "CPI-22DEC-TN0.1"
```

```yaml
id: 2
cmd: subscribe
params:
  channels: ["orderbook_delta", "ticker"]
  market_tickers: ["FED-23DEC-T3.00", "CORIVER-2024-T1030"]
```

```yaml
id: 3
cmd: subscribe
params:
  channels: ["fill"]
```

```yaml
id: 4
cmd: subscribe
params:
  channels: ["user_orders"]
```

```yaml
id: 5
cmd: subscribe
params:
  channels: ["market_lifecycle_v2"]
```

```yaml
id: 6
cmd: subscribe
params:
  channels: ["ticker"]
  market_ticker: "TSLA-23DEC-T200"
```

```yaml
id: 7
cmd: subscribe
params:
  channels: ["multivariate_market_lifecycle"]
```

```yaml
id: 8
cmd: subscribe
params:
  channels: ["ticker"]
  market_tickers: ["FED-23DEC-T3.00"]
  send_initial_snapshot: true
```

```yaml
id: 9
cmd: subscribe
params:
  channels: ["cfbenchmarks_value"]
  index_ids: ["BRTI", "ETHUSD_RTI"]
```

```yaml
id: 10
cmd: subscribe
params:
  channels: ["cfbenchmarks_value_5hz"]
  index_ids: ["BRTI"]
```

```yaml
id: 11
cmd: subscribe
params:
  channels: ["pyth_value"]
  underlying_tickers: ["Metal.XAU/USD", "Metal.XAG/USD"]
```

```yaml
id: 124
cmd: unsubscribe
params:
  sids: [1, 2]
```

```yaml
id: 3
cmd: list_subscriptions
```

--------------------------------

### Complete Example Script

Source: https://docs.kalshi.com/getting_started/quick_start_create_order

A complete Python script that demonstrates creating a first order on the Kalshi API. It includes a POST function for authenticated requests, finds an open market, and places a buy order.

```python
import requests
import uuid
from urllib.parse import urlparse
# Assumes you have the authentication code from the prerequisites

# Add POST function to your existing auth code
def post(private_key, api_key_id, path, data, base_url=BASE_URL):
    """Make an authenticated POST request to the Kalshi API."""
    timestamp = str(int(datetime.datetime.now().timestamp() * 1000))
    # Signing requires the full URL path from root (e.g. /trade-api/v2/portfolio/events/orders)
    sign_path = urlparse(base_url + path).path
    signature = create_signature(private_key, timestamp, "POST", sign_path)

    headers = {
        'KALSHI-ACCESS-KEY': api_key_id,
        'KALSHI-ACCESS-TIME': timestamp,
        'KALSHI-ACCESS-SIGNATURE': signature
    }

    return requests.post(base_url + path, headers=headers, json=data)

# Step 1: Find an open market
print("Finding an open market...")
response = requests.get('https://external-api.demo.kalshi.co/trade-api/v2/markets?limit=1&status=open')
market = response.json()['markets'][0]
print(f"Selected: {market['ticker']} - {market['title']}")

# Step 2: Place a buy order
print("\nPlacing order...")
client_order_id = str(uuid.uuid4())
order_data = {
    "ticker": market['ticker'],
    "side": "bid",
    "count": "1",
    "price": "0.0100",
    "time_in_force": "good_till_canceled",
    "self_trade_prevention_type": "taker_at_cross",
    "client_order_id": client_order_id
}

response = post(private_key, API_KEY_ID, '/portfolio/events/orders', order_data)

if response.status_code == 201:
    order = response.json()
    print(f"Order placed successfully!")
    print(f"Order ID: {order['order_id']}")
    print(f"Client Order ID: {client_order_id}")
    print(f"Remaining Count: {order['remaining_count']}")
else:
    print(f"Error: {response.status_code} - {response.text}")
```

--------------------------------

### GET /communications/id - Go, Java, Ruby examples

Source: https://docs.kalshi.com/api-reference/communications

Send a GET request to the communications ID endpoint. Requires the KALSHI-ACCESS-KEY, KALSHI-ACCESS-SIGNATURE, and KALSHI-ACCESS-TIMESTAMP headers. The response body contains the communications ID.

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://external-api.kalshi.com/trade-api/v2/communications/id"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("KALSHI-ACCESS-KEY", "<api-key>")
	req.Header.Add("KALSHI-ACCESS-SIGNATURE", "<api-key>")
	req.Header.Add("KALSHI-ACCESS-TIMESTAMP", "<api-key>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

```java
HttpResponse<String> response = Unirest.get("https://external-api.kalshi.com/trade-api/v2/communications/id")
  .header("KALSHI-ACCESS-KEY", "<api-key>")
  .header("KALSHI-ACCESS-SIGNATURE", "<api-key>")
  .header("KALSHI-ACCESS-TIMESTAMP", "<api-key>")
  .asString();
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://external-api.kalshi.com/trade-api/v2/communications/id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["KALSHI-ACCESS-KEY"] = '<api-key>'
request["KALSHI-ACCESS-SIGNATURE"] = '<api-key>'
request["KALSHI-ACCESS-TIMESTAMP"] = '<api-key>'

response = http.request(request)
puts response.read_body
```

--------------------------------

### Connect to Kalshi WebSocket and subscribe to orderbook updates

Source: https://docs.kalshi.com/getting_started/quick_start_websockets

Complete runnable example that connects to the Kalshi WebSocket API, authenticates with RSA-PSS signed headers, subscribes to orderbook_delta channel for a given market ticker, and processes snapshot, delta, and error messages. Requires replacing KEY_ID, PRIVATE_KEY_PATH, and MARKET_TICKER with your credentials and an open market; run with Python 3.7+.

```python
import asyncio
import base64
import json
import time
import websockets
from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.primitives.asymmetric import padding

# Configuration
KEY_ID = "your_api_key_id"
PRIVATE_KEY_PATH = "path/to/private_key.pem"
MARKET_TICKER = "KXHARRIS24-LSV"  # Replace with any open market
WS_URL = "wss://external-api-ws.demo.kalshi.co/trade-api/ws/v2"

def sign_pss_text(private_key, text: str) -> str:
    """Sign message using RSA-PSS"""
    message = text.encode('utf-8')
    signature = private_key.sign(
        message,
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.DIGEST_LENGTH
        ),
        hashes.SHA256()
    )
    return base64.b64encode(signature).decode('utf-8')

def create_headers(private_key, method: str, path: str) -> dict:
    """Create authentication headers"""
    timestamp = str(int(time.time() * 1000))
    msg_string = timestamp + method + path.split('?')[0]
    signature = sign_pss_text(private_key, msg_string)

    return {
        "Content-Type": "application/json",
        "KALSHI-ACCESS-KEY": KEY_ID,
        "KALSHI-ACCESS-SIGNATURE": signature,
        "KALSHI-ACCESS-TIMESTAMP": timestamp,
    }

async def orderbook_websocket():
    """Connect to WebSocket and subscribe to orderbook"""
    # Load private key
    with open(PRIVATE_KEY_PATH, 'rb') as f:
        private_key = serialization.load_pem_private_key(
            f.read(),
            password=None
        )

    # Create WebSocket headers
    ws_headers = create_headers(private_key, "GET", "/trade-api/ws/v2")

    async with websockets.connect(WS_URL, additional_headers=ws_headers) as websocket:
        print(f"Connected! Subscribing to orderbook for {MARKET_TICKER}")

        # Subscribe to orderbook
        subscribe_msg = {
            "id": 1,
            "cmd": "subscribe",
            "params": {
                "channels": ["orderbook_delta"],
                "market_ticker": MARKET_TICKER
            }
        }
        await websocket.send(json.dumps(subscribe_msg))

        # Process messages
        async for message in websocket:
            data = json.loads(message)
            msg_type = data.get("type")

            if msg_type == "subscribed":
                print(f"Subscribed: {data}")

            elif msg_type == "orderbook_snapshot":
                print(f"Orderbook snapshot: {data}")

            elif msg_type == "orderbook_delta":
                # The client_order_id field is optional - only present when you caused the change
                if 'client_order_id' in data.get('msg', {}):
                    print(f"Orderbook update (your order {data['msg']['client_order_id']}): {data}")
                else:
                    print(f"Orderbook update: {data}")

            elif msg_type == "error":
                print(f"Error: {data}")

# Run the example
if __name__ == "__main__":
    asyncio.run(orderbook_websocket())
```

--------------------------------

### GET /trade-api/v2/account/limits response with refill_rate and bucket_capacity

Source: https://docs.kalshi.com/changelog/index

Example response from GET /trade-api/v2/account/limits after Apr 30, 2026. Shows the nested per-bucket structure with refill_rate and bucket_capacity. When a bucket has no burst headroom, bucket_capacity equals refill_rate.

```json
{
  "usage_tier": "advanced",
  "read":  {"refill_rate": 200, "bucket_capacity": 200},
  "write": {"refill_rate": 100, "bucket_capacity": 200}
}
```

--------------------------------

### GET /series/{series_ticker}/markets/{ticker}/candlesticks

Source: https://docs.kalshi.com/api-reference/market/get-market-candlesticks

Retrieves candlestick data for a specific market. The endpoint requires a series ticker, market ticker, start and end timestamps, and a period interval. Optionally, it can include the latest candlestick before the start timestamp.

```APIDOC
## GET /series/{series_ticker}/markets/{ticker}/candlesticks

### Description
Retrieves candlestick data for a specific market. The time period length of each candlestick is specified in minutes, with valid values of 1 (1 minute), 60 (1 hour), and 1440 (1 day). Candlesticks for markets that settled before the historical cutoff are only available via `GET /historical/markets/{ticker}/candlesticks`.

### Method
GET

### Endpoint
/series/{series_ticker}/markets/{ticker}/candlesticks

### Parameters
#### Path Parameters
- **series_ticker** (string) - Required - Series ticker - the series that contains the target market
- **ticker** (string) - Required - Market ticker - unique identifier for the specific market

#### Query Parameters
- **start_ts** (integer, int64) - Required - Start timestamp (Unix timestamp). Candlesticks will include those ending on or after this time.
- **end_ts** (integer, int64) - Required - End timestamp (Unix timestamp). Candlesticks will include those ending on or before this time.
- **period_interval** (integer) - Required - Time period length of each candlestick in minutes. Valid values are 1 (1 minute), 60 (1 hour), or 1440 (1 day).
- **include_latest_before_start** (boolean) - Optional - If true, prepends the latest candlestick available before the start_ts. This synthetic candlestick is created by: 1. Finding the most recent real candlestick before start_ts 2. Projecting it forward to the first period boundary (calculated as the next period interval after start_ts)

### Request Example
GET /series/{series_ticker}/markets/{ticker}/candlesticks?start_ts=1700000000&end_ts=1700003600&period_interval=60&include_latest_before_start=true

### Response
#### Success Response (200)
- **candlesticks** (array) - List of candlestick objects, each containing open, high, low, close, and timestamp information.

#### Response Example
{
  "candlesticks": [
    {
      "open": 0.5,
      "high": 0.6,
      "low": 0.4,
      "close": 0.55,
      "ts": 1700000000
    }
  ]
}
```

--------------------------------

### Market Position Update Example

Source: https://docs.kalshi.com/asyncapi.yaml

Payload example for a real-time user market position update.

```json
type: market_position
sid: 14
msg:
  user_id: "user123"
  market_ticker: "FED-23DEC-T3.00"
  position_fp: "100.00"
  position_cost_dollars: "50.0000"
  realized_pnl_dollars: "10.0000"
  fees_paid_dollars: "1.0000"
  position_fee_cost_dollars: "0.5000"
  volume_fp: "15.00"
```
Tokens:
Raw