Kalshi Subaccounts API (2026): Create, Fund and Trade Them

What are Kalshi subaccounts?

Kalshi's docs describe them as a way to "partition its balance and positions into independent buckets under one set of API credentials." Every account has a primary subaccount, number 0, and can add numbered subaccounts 1 to 63, for 64 buckets in total. Each has its own cash, positions and orders, so each strategy's money and exposure stay in its own bucket.

Two limits matter before you plan around them. Subaccounts are, in Kalshi's words, "currently an API-only feature", not yet supported in the web or mobile app. And they are for Direct accounts; FCM members manage their customers through separate subtrader endpoints.

How are subaccounts different from sub-users?

They solve different problems. Kalshi's docs put it plainly: "Sub-users control who can act on the account; subaccounts control which funds and positions an action uses."

The two combine. A sub-user's permissions cover the whole account, so to confine someone, or a bot, to one subaccount, give them an API key restricted to it. Only the account owner can create API keys.

Who can create Kalshi subaccounts?

Any Direct account on the Advanced API tier or above. Advanced is the second of Kalshi's seven rate-limit tiers, and it comes from one call to POST /account/api_usage_level/upgrade. Kalshi's criterion is that "at least 1 of the user's last 100 Predictions orders was created via API", so place one order through the API first. The grant is permanent, the call costs 30 rate-limit tokens, and GET /account/limits shows your tier afterwards. The tiers themselves are covered in Kalshi API rate limits.

How do you create and fund a subaccount?

Five portfolio endpoints manage them:

With the official TypeScript SDK, kalshi-typescript 3.31.0, and the account owner's key:

import { readFileSync } from 'node:fs';
import { randomUUID } from 'node:crypto';
import { ApiKeysApi, Configuration, PortfolioApi } from 'kalshi-typescript';

const config = new Configuration({
  apiKey: 'YOUR_KEY_ID',
  privateKeyPem: readFileSync('kalshi-private-key.pem', 'utf8'),
  basePath: 'https://external-api.kalshi.com/trade-api/v2',
});
const portfolio = new PortfolioApi(config);

// 1. Create the next numbered subaccount on the default shard.
const { data: created } = await portfolio.createSubaccount({ exchange_index: 0 });
const sub = created.subaccount_number;

// 2. Move $250 into it from the primary account. This endpoint takes cents.
await portfolio.applySubaccountTransfer({
  client_transfer_id: randomUUID(),
  from_subaccount: 0,
  to_subaccount: sub,
  amount_cents: 25_000,
});

// 3. List every balance: one row per subaccount and exchange shard.
const { data: balances } = await portfolio.getSubaccountBalances();
for (const b of balances.subaccount_balances) console.log(b.subaccount_number, b.exchange_index, b.balance);

// 4. Mint an API key that can only read and trade this subaccount.
const { data: key } = await new ApiKeysApi(config).generateApiKey({ name: `strategy-${sub}`, key_type: 'ed25519', subaccount: sub });
console.log('restricted key', key.api_key_id); // key.private_key is shown once: store it securely

How do restricted API keys work?

Pass a subaccount number when you generate or register an API key, as step 4 above does with POST /api_keys/generate, and the key is locked to that subaccount. A restricted key can place and manage orders, read that subaccount's balance, positions, fills and settlements, use order groups and run the REST request for quote flow, all for its own subaccount. Requests that leave out subaccount act on the locked one, and naming any other is rejected.

It cannot transfer funds, manage subaccounts or API keys, or touch another subaccount's RFQs and quotes. Endpoints outside its scope return 403 with "this API key is restricted to a single sub-account and cannot access this endpoint". Restricted keys can also open WebSocket sessions, with every private channel scoped to their subaccount. That makes them the right credential for a bot: fund a subaccount with the capital it may use, and give the bot only that key. Key creation is covered in how to get a Kalshi API key.

How do you trade from a subaccount?

Pass its number. The V2 create-order body takes subaccount, where 0 is the primary, and the portfolio and cancel endpoints take it as a query parameter:

import { readFileSync } from 'node:fs';
import { Configuration, OrdersApi, PortfolioApi } from 'kalshi-typescript';

const config = new Configuration({
  apiKey: 'YOUR_KEY_ID',
  privateKeyPem: readFileSync('kalshi-private-key.pem', 'utf8'),
  basePath: 'https://external-api.kalshi.com/trade-api/v2',
});
const orders = new OrdersApi(config);
const portfolio = new PortfolioApi(config);
const sub = 1;

// Place an order that draws on subaccount 1's cash and lands in its positions.
const { data: placed } = await orders.createOrderV2({
  ticker: 'YOUR_MARKET_TICKER',
  side: 'bid',
  count: '5',
  price: '0.4000',
  time_in_force: 'good_till_canceled',
  self_trade_prevention_type: 'taker_at_cross',
  subaccount: sub,
});
console.log('order', placed.order_id);

// Read that subaccount's balance, then clear only its resting orders.
const { data: balance } = await portfolio.getBalance(sub);
console.log('subaccount', sub, 'balance', balance.balance_dollars);
await orders.cancelAllOrders(sub);

The parameter's default is the trap. Left out, it means different things on different endpoints:

So a cancel-all without a number clears every strategy's orders, and a positions read without one shows only the primary account. Pass the number every time.

How do subaccounts work with exchange shards?

Each balance lives on one shard. Kalshi now splits trading across matching engines, with crypto and commodities on shard 2 and tennis, baseball and basketball on shard 3, and its docs state that "subaccount balances are local to a specific exchange instance". To fund a subaccount that trades crypto, first move account cash to shard 2, then create the subaccount there with exchange_index: 2, then transfer into it with the same exchange_index. The intra-account transfer endpoint can also move cash between subaccounts on different shards, but Kalshi warns that those transfers run in up to three non-atomic steps, so a failure part way can leave funds in the primary account on either shard. Order groups also work within one shard only.

Does Kalshi support subaccounts for perps?

Yes. The perpetual futures API has its own pair of endpoints, POST /portfolio/margin/subaccounts and POST /portfolio/margin/subaccounts/transfer, with the same numbering and the same 63-subaccount limit. Margin orders take a subaccount, margin cancel-all accepts one, and GET /margin/balance returns cash per subaccount. As of October 2026, Kalshi lists production perps access as rolling out member by member, and transfers between event contract and margin balances as not yet available.

Subaccounts are a clean way to run several strategies side by side. If those strategies span venues, the Predictefy API covers Kalshi among 15+ venues in one normalized schema, and when it routes a Kalshi order, your API credentials are used for the one request that needs them and never stored. As with any trading, each subaccount's capital is at risk, so size it as money you can afford to lose.

Frequently Asked Questions