This is the complete method reference for @polymarket/clob-client, Polymarket’s official TypeScript SDK for interacting with the CLOB (Central Limit Order Book) API. Every method is documented with its signature, parameters, return type, and a working code example.

For the Python equivalent, see the py_clob_client Reference. For a conceptual overview of how the Polymarket API ecosystem works, see the Polymarket API Guide. For side-by-side comparison across platforms, see the Prediction Market API Reference.

Try it live: Test Polymarket endpoints in the API Playground — no setup required.

Installation and Setup

Installing @polymarket/clob-client

npm install @polymarket/clob-client ethers

The SDK requires ethers (v5 or v6) for wallet signing. If you prefer Viem, the SDK also supports WalletClient as a signer — see the Viem Alternative section below.

ClobClient Initialization

ClobClient is the main entry point for all SDK operations.

Signature:

import { ClobClient } from "@polymarket/clob-client";

const client = new ClobClient(
  host: string,
  chainId: number,
  signer: Wallet | WalletClient,
  creds?: ApiKeyCreds,
  signatureType?: number,
  funder?: string
);

Parameters:

ParameterTypeRequiredDescription
hoststringYesCLOB API base URL. Use "https://clob.polymarket.com" for production
chainIdnumberYesBlockchain chain ID. Use 137 for Polygon mainnet
signerWallet | WalletClientFor tradingAn ethers.js Wallet instance or a Viem WalletClient
credsApiKeyCredsNoPre-existing API credentials. Omit and derive them with createOrDeriveApiKey()
signatureTypenumberNoWallet type: 0 = EOA (MetaMask), 1 = POLY_PROXY (Magic/email), 2 = GNOSIS_SAFE (browser proxy)
funderstringFor proxy walletsThe proxy wallet address that holds your funds on Polymarket

Example — Read-only client (no authentication):

import { ClobClient } from "@polymarket/clob-client";

const client = new ClobClient("https://clob.polymarket.com", 137);

// Public endpoints work without auth
const price = await client.getPrice({ tokenID: "<token-id>", side: "BUY" });
console.log("Price:", price);

Example — Authenticated client (EOA wallet):

import { ClobClient } from "@polymarket/clob-client";
import { ethers } from "ethers";

const wallet = new ethers.Wallet("<your-private-key>");

const client = new ClobClient(
  "https://clob.polymarket.com",
  137,
  wallet,
  undefined, // creds — derive below
  0          // signatureType: EOA
);

// Derive API credentials
const creds = await client.createOrDeriveApiKey();

// Re-initialize with credentials
const authedClient = new ClobClient(
  "https://clob.polymarket.com",
  137,
  wallet,
  creds,
  0
);

Example — Authenticated client (Gnosis Safe / browser proxy wallet):

This is the most common configuration for wallets created through Polymarket’s web interface.

import { ClobClient } from "@polymarket/clob-client";
import { ethers } from "ethers";

const wallet = new ethers.Wallet("<your-private-key>");

const client = new ClobClient(
  "https://clob.polymarket.com",
  137,
  wallet,
  undefined,                  // creds — derive below
  2,                          // signatureType: GNOSIS_SAFE
  "<your-proxy-wallet-address>" // funder
);

const creds = await client.createOrDeriveApiKey();

const authedClient = new ClobClient(
  "https://clob.polymarket.com",
  137,
  wallet,
  creds,
  2,
  "<your-proxy-wallet-address>"
);

Viem Alternative

If you prefer Viem over ethers.js, the SDK accepts a WalletClient as the signer parameter.

import { ClobClient } from "@polymarket/clob-client";
import { createWalletClient, http } from "viem";
import { polygon } from "viem/chains";
import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount("<your-private-key>");

const walletClient = createWalletClient({
  account,
  chain: polygon,
  transport: http(),
});

const client = new ClobClient(
  "https://clob.polymarket.com",
  137,
  walletClient,
  undefined,
  2,
  "<your-proxy-wallet-address>"
);

Constructor Options

The ClobClient constructor also accepts an optional options object as the seventh parameter:

OptionTypeDefaultDescription
throwOnErrorbooleanfalseWhen true, the client throws ApiError on failed requests instead of returning error objects
geoBlockTokenstringundefinedPass a geo-block bypass token if you have one
const client = new ClobClient(
  "https://clob.polymarket.com",
  137,
  wallet,
  creds,
  2,
  "<proxy-address>",
  { throwOnError: true }
);

Authentication

createOrDeriveApiKey()

Derives or creates API credentials from your wallet signature. This is the recommended method for obtaining credentials. If credentials already exist for your wallet, it returns them. If not, it creates new ones.

Signature:

client.createOrDeriveApiKey(): Promise<ApiKeyCreds>

Returns: An ApiKeyCreds object containing:

FieldTypeDescription
keystringYour API key
secretstringYour API secret
passphrasestringYour API passphrase

Example:

import { ClobClient } from "@polymarket/clob-client";
import { ethers } from "ethers";

const wallet = new ethers.Wallet("<your-private-key>");

// Step 1: Create a temporary client without credentials
const tempClient = new ClobClient(
  "https://clob.polymarket.com",
  137,
  wallet,
  undefined,
  2,
  "<proxy-wallet-address>"
);

// Step 2: Derive credentials
const creds = await tempClient.createOrDeriveApiKey();
console.log("API Key:", creds.key);
console.log("Secret:", creds.secret);
console.log("Passphrase:", creds.passphrase);

// Step 3: Re-initialize with credentials for authenticated trading
const client = new ClobClient(
  "https://clob.polymarket.com",
  137,
  wallet,
  creds,
  2,
  "<proxy-wallet-address>"
);

Credentials are deterministic — deriving them again with the same wallet and signatureType produces the same result. You can safely store and reuse them across sessions.

Other Authentication Methods

MethodSignatureDescription
deriveApiKey()deriveApiKey(): Promise<ApiKeyCreds>Derives existing API credentials. Throws if none exist.
createApiKey()createApiKey(): Promise<ApiKeyCreds>Creates new API credentials. Overwrites any existing credentials.
getApiKeys()getApiKeys(): Promise<ApiKeyCreds[]>Returns all API key sets associated with your wallet.
deleteApiKey()deleteApiKey(): Promise<void>Deletes the current API credentials.

Use createOrDeriveApiKey() in most cases. The individual methods are useful when you need finer control — for example, rotating credentials with deleteApiKey() followed by createApiKey().

Balance Methods

getBalanceAllowance(params)

Returns your balance and token allowance for a specific asset type. Essential for checking whether you have sufficient funds and allowance set before trading.

Signature:

client.getBalanceAllowance(params: BalanceAllowanceParams): Promise<BalanceAllowanceResponse>

Parameters:

FieldTypeRequiredDescription
asset_typestringYes"COLLATERAL" for USDC, or "CONDITIONAL" for outcome tokens
token_idstringFor conditionalThe specific outcome token ID (required when asset_type is "CONDITIONAL")

Returns: An object with balance and allowance fields as strings (in wei for USDC, where 1 USDC = 10^6 wei).

Example — Check USDC balance:

const result = await client.getBalanceAllowance({
  asset_type: "COLLATERAL",
});
const balanceUsdc = parseInt(result.balance) / 1e6;
console.log(`Balance: ${balanceUsdc.toFixed(2)} USDC`);
console.log(`Allowance: ${result.allowance}`);

Example — Check conditional token balance:

const result = await client.getBalanceAllowance({
  asset_type: "CONDITIONAL",
  token_id: "<outcome-token-id>",
});
console.log(`Token balance: ${result.balance}`);
console.log(`Token allowance: ${result.allowance}`);

updateBalanceAllowance(params)

Sets or updates the token allowance for a specific asset type. You may need to call this before trading if your allowance is insufficient.

Signature:

client.updateBalanceAllowance(params: BalanceAllowanceParams): Promise<void>

Parameters: Same as getBalanceAllowance() — specify asset_type and optionally token_id.

Example:

await client.updateBalanceAllowance({
  asset_type: "COLLATERAL",
});
console.log("Allowance updated for USDC");

Market Data Methods

These methods are available without authentication. You can use a read-only client (no signer) to call any of them.

getPrice(params)

Returns the best available price for a given side (BUY or SELL) on a specific outcome token.

Signature:

client.getPrice(params: { tokenID: string; side: string }): Promise<string>

Parameters:

FieldTypeDescription
tokenIDstringThe outcome token ID
sidestring"BUY" or "SELL"

Returns: A string representing the best price as a decimal between 0 and 1.

Example:

const price = await client.getPrice({
  tokenID: "<token-id>",
  side: "BUY",
});
console.log(`Best buy price: $${price}`);
// Example output: Best buy price: $0.65

getMidpoint(params)

Returns the midpoint price between the best bid and best ask for an outcome token.

Signature:

client.getMidpoint(params: { tokenID: string }): Promise<string>

Example:

const midpoint = await client.getMidpoint({ tokenID: "<token-id>" });
console.log(`Midpoint: $${midpoint}`);

getOrderBook(params)

Returns the full order book for a specific outcome token, including all bids and asks with their prices and sizes.

Signature:

client.getOrderBook(params: { tokenID: string }): Promise<OrderBookSummary>

Returns: An OrderBookSummary object with bids and asks arrays. Each entry contains price and size.

Example:

const book = await client.getOrderBook({ tokenID: "<token-id>" });

console.log("Top bids:");
book.bids.slice(0, 5).forEach((bid) => {
  console.log(`  $${bid.price} — ${bid.size} shares`);
});

console.log("Top asks:");
book.asks.slice(0, 5).forEach((ask) => {
  console.log(`  $${ask.price} — ${ask.size} shares`);
});

getOrderBooks(params)

Fetches order books for multiple tokens in a single request.

Signature:

client.getOrderBooks(params: { tokenIDs: string[] }): Promise<OrderBookSummary[]>

Example:

const books = await client.getOrderBooks({
  tokenIDs: ["<token-id-1>", "<token-id-2>"],
});

books.forEach((book, i) => {
  console.log(`Book ${i}: ${book.bids.length} bids, ${book.asks.length} asks`);
});

getPricesHistory(params)

Returns historical price data for a specific outcome token.

Signature:

client.getPricesHistory(params: {
  tokenID: string;
  startTs?: number;
  endTs?: number;
  interval?: string;
  fidelity?: number;
}): Promise<PriceHistoryPoint[]>

Parameters:

FieldTypeDescription
tokenIDstringThe outcome token ID
startTsnumberStart timestamp (Unix seconds)
endTsnumberEnd timestamp (Unix seconds)
intervalstringTime interval (e.g., "1h", "1d")
fidelitynumberNumber of data points to return

Example:

const now = Math.floor(Date.now() / 1000);
const oneDayAgo = now - 86400;

const history = await client.getPricesHistory({
  tokenID: "<token-id>",
  startTs: oneDayAgo,
  endTs: now,
  fidelity: 100,
});

history.forEach((point) => {
  console.log(`${new Date(point.t * 1000).toISOString()}: $${point.p}`);
});

getTickSize(tokenId)

Returns the minimum tick size (price increment) for a specific token. Orders must be priced in multiples of this value.

Signature:

client.getTickSize(tokenID: string): Promise<string>

Example:

const tickSize = await client.getTickSize("<token-id>");
console.log(`Tick size: ${tickSize}`);
// Example output: Tick size: 0.01

getMidpoints and getPrices

Batch variants that return midpoints or prices for multiple tokens.

Signatures:

client.getMidpoints(params: { tokenIDs: string[] }): Promise<Record<string, string>>
client.getPrices(params: { tokenIDs: string[] }): Promise<Record<string, string>>

Example:

const midpoints = await client.getMidpoints({
  tokenIDs: ["<token-1>", "<token-2>"],
});

Object.entries(midpoints).forEach(([tokenId, price]) => {
  console.log(`${tokenId}: $${price}`);
});

Order Types

Before placing orders, understand the two primary order argument interfaces.

OrderArgs

Used for limit orders where you specify a price and size.

interface OrderArgs {
  tokenID: string;     // The outcome token to trade
  price: number;       // Limit price, decimal 0.01 to 0.99
  size: number;        // Order size in USDC units
  side: Side;          // Side.BUY or Side.SELL
  feeRateBps?: number; // Fee rate in basis points (optional)
  nonce?: number;      // Unique nonce (auto-generated if omitted)
  expiration?: number; // Unix timestamp for order expiry (optional)
}

Key details:

  • price is a decimal between 0 and 1. A price of 0.65 means 65% implied probability and costs $0.65 per share.
  • size is denominated in USDC. A size of 50 means $50 worth of the outcome token at the specified price.
  • Import Side from the SDK: import { Side } from "@polymarket/clob-client";

MarketOrderArgs

Used for market orders where you specify how much USDC to spend rather than a specific price.

interface MarketOrderArgs {
  tokenID: string;     // The outcome token to trade
  amount: number;      // USDC amount to spend
}

OrderType Enum

Specify how long your order stays active:

ValueDescription
OrderType.GTCGood-Til-Cancelled. Stays on the book until filled or cancelled.
OrderType.FOKFill-Or-Kill. Must fill entirely and immediately, or the entire order is cancelled.
OrderType.GTDGood-Til-Date. Stays on the book until a specified expiration time.

Import with: import { OrderType } from "@polymarket/clob-client";

Order Placement

All order placement methods require an authenticated client with valid API credentials.

createOrder(orderArgs)

Creates and signs an order locally without submitting it to the CLOB. Returns a signed OrderPayload that you can inspect, log, or submit later with postOrder().

Signature:

client.createOrder(orderArgs: OrderArgs): Promise<OrderPayload>

Returns: A signed OrderPayload object ready for submission.

Example:

import { ClobClient, Side } from "@polymarket/clob-client";

const signedOrder = await client.createOrder({
  tokenID: "<token-id>",
  price: 0.55,
  size: 100,
  side: Side.BUY,
});

console.log("Signed order:", JSON.stringify(signedOrder, null, 2));
// Inspect the order before submitting...

postOrder(signedOrder, orderType)

Submits a previously signed order to the CLOB.

Signature:

client.postOrder(order: OrderPayload, orderType?: OrderType): Promise<OrderResponse>

Parameters:

FieldTypeDescription
orderOrderPayloadA signed order from createOrder()
orderTypeOrderTypeOrder type. Defaults to OrderType.GTC.

Example:

import { OrderType } from "@polymarket/clob-client";

const signedOrder = await client.createOrder({
  tokenID: "<token-id>",
  price: 0.55,
  size: 100,
  side: Side.BUY,
});

const response = await client.postOrder(signedOrder, OrderType.GTC);
console.log("Order ID:", response.orderID);
console.log("Status:", response.status);

createAndPostOrder(orderArgs, orderType)

Creates, signs, and submits an order in a single call. This is the most convenient method for straightforward order placement.

Signature:

client.createAndPostOrder(
  orderArgs: OrderArgs,
  orderType?: OrderType
): Promise<OrderResponse>

Example:

import { ClobClient, Side, OrderType } from "@polymarket/clob-client";

const response = await client.createAndPostOrder(
  {
    tokenID: "<token-id>",
    price: 0.55,
    size: 100,
    side: Side.BUY,
  },
  OrderType.GTC
);

console.log("Order placed:", response.orderID);

When to use createOrder + postOrder vs createAndPostOrder:

  • Use createAndPostOrder() for simple, immediate order placement.
  • Use createOrder() + postOrder() when you need to inspect the signed payload, add logging, or batch multiple orders before submitting.

createMarketOrder(marketOrderArgs)

Creates a market order that executes at the best available price. Market orders use Fill-Or-Kill (FOK) execution — they fill immediately or are cancelled entirely.

Signature:

client.createMarketOrder(args: MarketOrderArgs): Promise<OrderPayload>

Example:

const marketOrder = await client.createMarketOrder({
  tokenID: "<token-id>",
  amount: 50, // Spend $50 USDC at the best available price
});

const response = await client.postOrder(marketOrder, OrderType.FOK);
console.log("Market order filled:", response.orderID);

Batch Operations

For placing multiple orders at once, create them individually and submit as a batch.

createOrders / postOrders:

// Create and post multiple orders in a batch
const prices = [0.50, 0.52, 0.54, 0.56, 0.58];

const signedOrders = await Promise.all(
  prices.map((price) =>
    client.createOrder({
      tokenID: "<token-id>",
      price,
      size: 50,
      side: Side.BUY,
    })
  )
);

// Submit all orders at once
const responses = await client.postOrders(signedOrders, OrderType.GTC);
console.log(`Placed ${responses.length} orders`);

This is significantly more efficient than calling createAndPostOrder() in a loop, as it reduces the number of API calls.

Order Management

getOrder(orderId)

Retrieves the details of a specific order by its ID.

Signature:

client.getOrder(orderID: string): Promise<Order>

Example:

const order = await client.getOrder("<order-id>");
console.log(`Order ${order.id}: ${order.side} ${order.size} @ $${order.price}`);
console.log(`Status: ${order.status}`);

getOrders(params)

Retrieves your open orders with optional filters.

Signature:

client.getOrders(params?: {
  market?: string;
  asset_id?: string;
}): Promise<Order[]>

Example:

// Get all open orders
const orders = await client.getOrders();
console.log(`You have ${orders.length} open orders`);

// Get orders for a specific market
const marketOrders = await client.getOrders({
  market: "<condition-id>",
});

getOrdersHistory(params)

Retrieves your historical orders (filled, cancelled, etc.).

Signature:

client.getOrdersHistory(params?: {
  market?: string;
  asset_id?: string;
}): Promise<Order[]>

Example:

const history = await client.getOrdersHistory();
history.forEach((order) => {
  console.log(`${order.side} ${order.size} @ $${order.price} — ${order.status}`);
});

cancelOrder(orderId)

Cancels a specific open order.

Signature:

client.cancelOrder(orderID: string): Promise<CancelResponse>

Example:

const result = await client.cancelOrder("<order-id>");
console.log("Cancelled:", result);

cancelOrders(orderIds)

Cancels multiple orders in a single request.

Signature:

client.cancelOrders(orderIDs: string[]): Promise<CancelResponse[]>

Example:

const results = await client.cancelOrders([
  "<order-id-1>",
  "<order-id-2>",
  "<order-id-3>",
]);
console.log(`Cancelled ${results.length} orders`);

cancelAll()

Cancels all open orders across all markets.

Signature:

client.cancelAll(): Promise<CancelResponse[]>

Example:

const results = await client.cancelAll();
console.log(`Cancelled all ${results.length} open orders`);

cancelMarketOrders(params)

Cancels all open orders for a specific market.

Signature:

client.cancelMarketOrders(params: {
  market: string;
  asset_id?: string;
}): Promise<CancelResponse[]>

Example:

const results = await client.cancelMarketOrders({
  market: "<condition-id>",
});
console.log(`Cancelled ${results.length} orders in market`);

Position Methods

getPositions(params)

Retrieves your current positions across all markets. Each position represents your holdings of a specific outcome token.

Signature:

client.getPositions(params?: {
  market?: string;
  asset_id?: string;
}): Promise<Position[]>

Example:

const positions = await client.getPositions();
positions.forEach((pos) => {
  console.log(`Token: ${pos.asset_id}`);
  console.log(`  Size: ${pos.size}`);
  console.log(`  Avg entry: $${pos.avgPrice}`);
});

getTrades(params)

Retrieves your trade history.

Signature:

client.getTrades(params?: {
  market?: string;
  asset_id?: string;
  before?: string;
  after?: string;
}): Promise<Trade[]>

Example:

const trades = await client.getTrades();
trades.forEach((trade) => {
  console.log(
    `${trade.side} ${trade.size} @ $${trade.price} — ${trade.status}`
  );
});

getNotifications(params)

Retrieves your trade notifications (fills, cancellations, etc.).

Signature:

client.getNotifications(): Promise<Notification[]>

Example:

const notifications = await client.getNotifications();
notifications.forEach((n) => {
  console.log(`[${n.type}] ${n.message}`);
});

Server Utilities

getOk()

Health check endpoint. Returns "OK" if the CLOB server is operational.

Signature:

client.getOk(): Promise<string>

Example:

const status = await client.getOk();
console.log("Server status:", status); // "OK"

getServerTime()

Returns the CLOB server’s current time. Useful for synchronizing timestamps when signing orders.

Signature:

client.getServerTime(): Promise<string>

Example:

const serverTime = await client.getServerTime();
console.log("Server time:", serverTime);

If your local clock is significantly out of sync with the server, order signatures may be rejected. Use this method to detect clock drift.

Error Handling

The SDK supports two error handling patterns depending on how you configure the client.

Option 1: throwOnError Mode

When throwOnError is set to true, the client throws an ApiError on any failed API request. This integrates naturally with try/catch.

import { ClobClient, ApiError, Side, OrderType } from "@polymarket/clob-client";

const client = new ClobClient(
  "https://clob.polymarket.com",
  137,
  wallet,
  creds,
  2,
  "<proxy-address>",
  { throwOnError: true }
);

try {
  const result = await client.createAndPostOrder(
    {
      tokenID: "<token-id>",
      price: 0.55,
      size: 100,
      side: Side.BUY,
    },
    OrderType.GTC
  );
  console.log("Order placed:", result.orderID);
} catch (error) {
  if (error instanceof ApiError) {
    console.error("API Error:", error.message);
  } else {
    console.error("Unexpected error:", error);
  }
}

Option 2: Check Response (Default)

Without throwOnError, failed requests return an object with an error field instead of throwing. You must check the response manually.

const result = await client.createAndPostOrder(
  {
    tokenID: "<token-id>",
    price: 0.55,
    size: 100,
    side: Side.BUY,
  },
  OrderType.GTC
);

if (result.error) {
  console.error("Order failed:", result.error);
} else {
  console.log("Order placed:", result.orderID);
}

Recommendation: Use throwOnError: true for production bots. It prevents silent failures and makes error logging straightforward.

Common Pitfalls

These are the most frequent issues developers encounter with the TypeScript SDK:

  1. Wrong signatureType — Using 0 (EOA) when your Polymarket account uses a proxy wallet (should be 1 or 2). See the Polymarket Auth Troubleshooting guide for diagnostic steps.

  2. Forgetting the funder for proxy wallets — If your signatureType is 1 (POLY_PROXY) or 2 (GNOSIS_SAFE), you must pass the funder parameter with your proxy wallet address. Without it, order signatures are invalid.

  3. Price not in 0-1 decimal range — Prices must be decimals between 0.01 and 0.99. Passing 65 instead of 0.65 will cause order rejection. The SDK does not auto-convert.

  4. Size is in USDC, not shares — A size of 50 means $50 USDC, not 50 shares. The number of shares you receive depends on the price.

  5. Not awaiting async methods — Every method on ClobClient returns a Promise. Forgetting await produces a pending Promise object instead of the actual result.

  6. Stale credentials after key rotation — If you call deleteApiKey() and then createApiKey(), you must re-initialize the client with the new credentials. Old credential references become invalid.

  7. Clock drift — Order signatures include timestamps. If your system clock is more than a few seconds off from the CLOB server, signatures are rejected. Use getServerTime() to detect drift.

FAQ

How do I install the Polymarket TypeScript SDK?

Run npm install @polymarket/clob-client ethers in your project directory. The SDK requires ethers.js for wallet signing operations. Once installed, import ClobClient from @polymarket/clob-client and create a new instance with the Polymarket CLOB host URL (https://clob.polymarket.com), chain ID 137 (Polygon), and an ethers.Wallet signer created from your private key.

What is the difference between createOrder and createAndPostOrder?

createOrder() only creates and signs the order locally, returning an OrderPayload object. The order is not submitted to the CLOB until you call postOrder() with that payload. createAndPostOrder() does both steps in a single call — it creates, signs, and submits the order to the CLOB, returning the order response directly. Use createOrder() when you want to inspect signed payloads, add custom logging, or batch multiple orders together before submission with postOrders().

How do I set up authentication in the TypeScript SDK?

First, initialize ClobClient with your private key (via ethers.Wallet), the correct signatureType (0 for EOA/MetaMask, 1 for Magic Link/email wallets, 2 for Gnosis Safe browser proxy wallets), and your funder address if using a proxy wallet. Then call createOrDeriveApiKey() to obtain your API credentials. Finally, create a new ClobClient instance passing those credentials as the creds parameter. The credentials are deterministic and can be stored for reuse across sessions.

Can I use the Polymarket TypeScript SDK with Viem instead of ethers.js?

Yes. The SDK supports both ethers.Wallet and Viem WalletClient as signers. Create a WalletClient using Viem’s createWalletClient() function configured for the Polygon chain, then pass it as the signer parameter to ClobClient. All other parameters and method calls remain the same regardless of which signing library you use.

What price format does the Polymarket TypeScript SDK use?

Prices are decimals between 0 and 1 representing probability. A price of 0.65 means 65% implied probability and costs $0.65 per share. Order sizes are in USDC units — a size of 50 means $50 worth of the outcome token at the specified price. The minimum price increment (tick size) varies by market; check it with getTickSize(). Always use the decimal format; the SDK does not accept percentages or cent values.

See Also

This guide is maintained by AgentBets.ai. Found an error or API change we missed? Let us know on Twitter.

Not financial advice. Built for builders.