Quickstart

This guide walks you through placing an order on Polymarket end-to-end.

Install the SDK

npm install @polymarket/clob-client-v2 viem

pip install py-clob-client-v2

cargo add polymarket_client_sdk_v2 --features clob

Set Up Your Client

Derive your API credentials and initialize the trading client. This example uses a deposit wallet with signature type 3 (POLY_1271), which is the wallet path for new API users:

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

const HOST = "https://clob.polymarket.com";
const CHAIN_ID = 137; // Polygon mainnet
const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const signer = createWalletClient({ account, transport: http() });
const depositWalletAddress = process.env.DEPOSIT_WALLET_ADDRESS!;

// Derive API credentials
const tempClient = new ClobClient({ host: HOST, chain: CHAIN_ID, signer });
const apiCreds = await tempClient.createOrDeriveApiKey();

// Initialize trading client
const client = new ClobClient({
  host: HOST,
  chain: CHAIN_ID,
  signer,
  creds: apiCreds,
  signatureType: SignatureTypeV2.POLY_1271,
  funderAddress: depositWalletAddress,
});

from py_clob_client_v2 import ClobClient, SignatureTypeV2
import os

host = "https://clob.polymarket.com"
chain = 137  # Polygon mainnet
private_key = os.getenv("PRIVATE_KEY")
deposit_wallet_address = os.getenv("DEPOSIT_WALLET_ADDRESS")

# Derive API credentials
temp_client = ClobClient(host, key=private_key, chain_id=chain)
api_creds = temp_client.create_or_derive_api_key()

# Initialize trading client
client = ClobClient(
    host,
    key=private_key,
    chain_id=chain,
    creds=api_creds,
    signature_type=SignatureTypeV2.POLY_1271,
    funder=deposit_wallet_address
)

use std::str::FromStr;
use polymarket_client_sdk_v2::POLYGON;
use polymarket_client_sdk_v2::auth::{LocalSigner, Signer};
use polymarket_client_sdk_v2::clob::types::SignatureType;
use polymarket_client_sdk_v2::clob::{Client, Config};

let private_key = std::env::var("POLYMARKET_PRIVATE_KEY")?;
let signer = LocalSigner::from_str(&private_key)?
    .with_chain_id(Some(POLYGON));
let deposit_wallet = std::env::var("DEPOSIT_WALLET_ADDRESS")?.parse()?;

// Derive API credentials and initialize client
let client = Client::new("https://clob.polymarket.com", Config::default())?
    .authentication_builder(&signer)
    .funder(deposit_wallet)
    .signature_type(SignatureType::Poly1271)
    .authenticate()
    .await?;

Existing EOA, Safe, and Proxy integrations can keep using their current signature type and funder address. See Signature Types for all wallet types.

Before trading from a deposit wallet, the deposit wallet needs pUSD and the required trading approvals. See the Deposit Wallet Guide for wallet creation, funding, approvals, and balance sync.

Place an Order

Get a token ID from the Markets API, then create and submit your order:

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

const response = await client.createAndPostOrder(
  {
    tokenID: "YOUR_TOKEN_ID",
    price: 0.5,
    size: 10,
    side: Side.BUY,
  },
  {
    tickSize: "0.01",
    negRisk: false, // Set to true for multi-outcome markets
  },
  OrderType.GTC,
);

console.log("Order ID:", response.orderID);
console.log("Status:", response.status);

from py_clob_client_v2 import OrderArgs, OrderType, PartialCreateOrderOptions
from py_clob_client_v2.order_builder.constants import BUY

response = client.create_and_post_order(
    OrderArgs(
        token_id="YOUR_TOKEN_ID",
        price=0.50,
        size=10,
        side=BUY,
    ),
    options=PartialCreateOrderOptions(
        tick_size="0.01",
        neg_risk=False,  # Set to True for multi-outcome markets
    ),
    order_type=OrderType.GTC
)

print("Order ID:", response["orderID"])
print("Status:", response["status"])

use polymarket_client_sdk_v2::clob::types::Side;
use polymarket_client_sdk_v2::types::dec;

let token_id = "YOUR_TOKEN_ID".parse()?;

// Tick size and neg risk are auto-fetched by the order builder
let order = client
    .limit_order()
    .token_id(token_id)
    .price(dec!(0.50))
    .size(dec!(10))
    .side(Side::Buy)
    .build()
    .await?;
let signed_order = client.sign(&signer, order).await?;
let response = client.post_order(signed_order).await?;

println!("Order ID: {}", response.order_id);
println!("Status: {:?}", response.status);

Look up a market’s tickSize and negRisk values using the SDK’s getTickSize() and getNegRisk() methods, or from the market object returned by the API.

Check Your Orders

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

// View your trade history
const trades = await client.getTrades();
console.log(`You've made ${trades.length} trades`);

// Cancel an order
await client.cancelOrder(response.orderID);

# View all open orders
open_orders = client.get_orders()
print(f"You have {len(open_orders)} open orders")

# View your trade history
trades = client.get_trades()
print(f"You've made {len(trades)} trades")

# Cancel an order
client.cancel(order_id=response["orderID"])

use polymarket_client_sdk_v2::clob::types::request::{OrdersRequest, TradesRequest};

// View all open orders
let open_orders = client.orders(&OrdersRequest::default(), None).await?;
println!("You have {} open orders", open_orders.data.len());

// View your trade history
let trades = client.trades(&TradesRequest::default(), None).await?;
println!("You've made {} trades", trades.data.len());

// Cancel an order
client.cancel_order(&response.order_id).await?;

Troubleshooting

L2 AUTH NOT AVAILABLE - Invalid Signature

Wrong private key, signature type, or funder address for the derived API credentials.

Check that signatureType matches your account type (0, 1, 2, or 3)
Ensure funder is correct for your wallet type
Re-derive credentials with createOrDeriveApiKey() if unsure

Order rejected - insufficient balance

Your funder address doesn’t have enough tokens:

BUY orders: need pUSD in your funder address
SELL orders: need outcome tokens in your funder address
Ensure you have more pUSD than what’s committed in open orders

Order rejected - insufficient allowance

You need to approve the Exchange contract to spend your tokens. Deposit wallet approvals must be executed from the deposit wallet through a relayer WALLET batch. Existing Safe and Proxy users should use their current relayer approval flow.

What is my funder address

Your funder address is the wallet where your funds are held:

EOA (type 0): Your wallet address directly
Deposit wallet (type 3): The deposit wallet deployed for the owner or session signer
Proxy/Safe wallet (type 1 or 2): Existing Polymarket.com wallet address

New API users should create a deposit wallet. Existing Proxy and Safe users can continue using their current wallet address.

Blocked by Cloudflare or Geoblock

You’re trying to place a trade from a restricted region. See Geographic Restrictions for details.

Troubleshooting

Next Steps

Create Orders

Order Attribution

​Troubleshooting

​Next Steps

Create Orders

Order Attribution

Troubleshooting

Next Steps