Skip to main content
POST
Create Order
Before creating orders:
  1. Fetch market data via Get Market Details to get venue and token IDs
  2. Sign the order using EIP-712 with venue.exchange as verifyingContract
  3. Ensure you have token approvals set up, including the USDC approval to venue.feeModule on new trading venues
Order creation can be temporarily restricted during maintenance. In post_only, only orders with postOnly: true are accepted. In cancel_only or disabled, new orders return 425 Too Early with a trading-mode code. Check Maintenance Mode before sending orders.

​
Authentication

Use a scoped API token with HMAC signing and the trading scope.

​
Signed order rules

For client-signed orders, signature and signatureType are both required. They must either both be present or both be omitted. Omission is accepted only for delegated server signing with an HMAC token carrying delegated_signing. nonce is required and must be the numeric value 0. expiration may be omitted; omission is signed as zero. If supplied, it must represent zero, for example "0". Non-zero expiration is not supported. Amounts are integer raw units with 6 decimals. makerAmount must be at least 100 raw units; this is the API’s only order-size floor and exists to reject dust. The web app applies its own, larger minimum order value before submitting, but that is a web-app rule and does not apply to orders placed through the API or the SDKs. For GTC and FAK orders, price is required and may have at most three decimal places, so prices run from 0.001 to 0.999. The collateral equation must be exact. price × contracts must be an integer raw-unit amount, without rounding. postOnly is supported only for GTC orders.

​
Optional fields

​
Receive window

POST /orders supports optional receive-window controls for clients that want freshness checks on order submission. Send these fields at the top level of the request body, next to order, orderType, and marketSlug; never put them inside the EIP-712 signed order object.
Keep trading hosts NTP-synced. If the timestamp is too far in the future or older than the receive window, the API returns 425 Too Early. Do not retry the same signed payload after a receive-window 425; build and sign a fresh order. If the 425 body has a trading-mode code, refresh maintenance status instead.

​
Self-trade prevention

POST /orders can reject or cancel orders that would match against your own resting order on the same token.
With cancel_maker, matching continues against the remaining non-self liquidity, and limit orders still never execute past their limit price. Outcomes on the placement response:
  • A rejected taker (cancel_taker / cancel_both) returns settlementStatus: "CANCELED" with reason: "STP_TAKER_REJECTED".
  • A cancel_maker taker lists the cancelled resting order IDs in stpMakerCancels and keeps its normal status (UNMATCHED when nothing else fills it); no reason is set.
stpPolicy is a top-level request field. Do not include it inside the EIP-712 signed order object.
SDK support. Self-trade prevention is available in the TypeScript, Python, Rust, and Go SDKs. Pass the policy on order creation and read the outcome from the execution object on the response. See TypeScript, Python, Rust, and Go.
Where does ownerId come from? It is the id field returned by GET /profiles/me or GET /profiles/{address}. For partner sub-accounts, it is the profileId returned by POST /profiles/partner-accounts, or recovered with GET /profiles/partner-accounts.
ownerId must match the profile that owns the order (see Programmatic API — EOA flow):
  • Partner EOA + signed order + onBehalfOf: set both onBehalfOf and ownerId to the sub-account’s profileId. order.maker and order.signer must match that sub-account’s wallet. A mismatched ownerId returns 400 with the message "Profile ID does not match the order owner".
  • Delegated signing (unsigned order, delegated_signing scope, server wallet sub-account): send the target profile ID as both onBehalfOf and ownerId. The server normalizes ownerId to that target when it signs. Omit the client signature per Delegated signing below.
  • Trading as yourself (no onBehalfOf): ownerId is your own profile id (the SDK often fills this after fetching your profile).
  • Signer does not match - you should use embedded address for smart wallet: your profile is in smart-wallet trading mode, which self-signed API orders can’t satisfy. Switch to EOA mode. See Trading wallet mode.

​
Delegated signing

Partners place orders for a managed sub-account by setting body onBehalfOf to its profile ID. A client-signed order requires trading; the target must belong to the authenticated partner. With both trading and delegated_signing, partners may instead omit both signature and signatureType. The request must still include the target profile ID as both onBehalfOf and ownerId. The server signs using a Privy server wallet linked to that profile, replaces maker and signer with that wallet address, and normalizes ownerId to the target. See Authentication.

​
Fee rate

On fee-enabled markets (metadata.fee: true), a signed order’s feeRateBps must equal the order owner’s effectiveFeeRateBps. Read your own rate from GET /profiles/me. A partner cannot read a sub-account’s private profile with its own credentials; use the sub-account’s rate when signing for it. On fee-disabled markets, sign with feeRateBps: 0. Unsigned delegated orders are signed by the server with the sub-account’s effective rate. On new trading venues (venue.feeModuleType: "COLLATERAL"), sign with feeRateBps: 0 on every order, whatever the market’s metadata.fee flag or your profile’s rate. Any other value is rejected with FEE_RATE_MISMATCH. Unsigned delegated orders on these venues are signed by the server with 0.

​
Execution response

The response includes an execution object with settlement details:
DELAYED (taker delay). Some markets apply a short hold to marketable (taker) orders before the matching engine fills them. On such a market, a marketable order’s response returns immediately with settlementStatus: "DELAYED", matched: false, zero totalsRaw, and an eligibleAt timestamp. It does not block until the trade is mined. Track the outcome over subscribe_order_events (provisional MATCHED → terminal MINED / FAILED), correlating by order.id and tradeEventId; MATCHED does not carry clientOrderId. A released FAK that fills partially gets one MATCHED and one terminal frame for the whole fill, plus an OME EXECUTION frame with status: "PARTIALLY_FILLED". A FAK that matches nothing at release emits only an OME EXECUTION frame with status: "KILLED", and POST /orders/status/batch reports it as settlementStatus: "UNMATCHED". postOnly orders are never delayed.Which orders are held: FOK and FAK orders are always held for the delay. A GTC order is submitted immediately and rests at once if it rests; only a GTC that would cross the book is held instead, returning the same DELAYED response, so a GTC is delayed only when it would have taken. postOnly orders are never held. The hold length is the market’s settings.takerDelayMs.During the hold the order is not on the book and emits no order or orderbook events; it first appears at eligibleAt. Cancellation is never delayed: cancelling a held order before eligibleAt removes it before it reaches the matching engine.

​
Errors

If the signed fee is incorrect, the API returns 400:
Build and sign a new order using expectedFeeRateBps before resubmitting. Changing only the JSON does not update the EIP-712 signature. On new trading venues, an order that is not postOnly (BUY or SELL) also needs a USDC approval to venue.feeModule from the signing wallet. Without it, the API returns 400:
Approve USDC to venue.feeModule once, then resubmit.

Authorizations

​
lmts-api-key
string
header
required

Scoped API token with HMAC-SHA256 signing. Requires three headers: lmts-api-key (token ID), lmts-timestamp (ISO-8601), lmts-signature (Base64-encoded HMAC). See Authentication docs for details.

Body

application/json

Order creation data including signature and order parameters

​
order
object
required

Order details including signature and amounts

​
ownerId
integer
required

Required profile ID of the order owner. For delegated signing, send the target profile ID as both ownerId and onBehalfOf.

Example:

12345

​
orderType
enum<string>
required

Order type (GTC=Good Till Cancelled, FAK=Fill And Kill, FOK=Fill Or Kill)

Available options:
FAK,
FOK,
GTC
Example:

"GTC"

​
marketSlug
string
required

Market identifier slug

Example:

"biden-vs-trump-2024"

​
postOnly
boolean

Reject the order if it would match immediately. Supported only for GTC orders.

Example:

true

​
clientOrderId
string

Optional owner-scoped uniqueness and deduplication key. The submitted value is limited to 128 characters, then trimmed; blank values are rejected. Reuse returns 409 rather than replaying an earlier response.

Maximum string length: 128
Example:

"client-order-001"

​
onBehalfOf
integer

Managed profile ID for partner placement. Requires trading and a partner relationship; unsigned delegated placement also requires delegated_signing.

Required range: x >= 1
Example:

12345

​
timestamp
integer

Optional client-stamped order creation time, Unix ms epoch. Top-level request field; not part of the EIP-712 signed order payload.

Required range: x >= 0
Example:

1735689600000

​
recvWindow
integer

Optional maximum accepted order age in milliseconds. Valid range: 1 to 10000. If omitted, the server applies a 2000 ms default receive window. Top-level request field; not part of the EIP-712 signed order payload.

Required range: 1 <= x <= 10000
Example:

1500

​
stpPolicy
enum<string>

Self-trade prevention policy. If omitted, defaults to cancel_maker. Top-level request field; not part of the EIP-712 signed order payload.

Available options:
cancel_both,
cancel_maker,
cancel_taker
Example:

"cancel_maker"

Response

Order accepted. It may be resting, delayed, matched, settled, canceled by STP, or accepted with a settlement failure reported in execution.

​
order
object
required

Order details including slim market and owner

​
execution
object
required

Execution and settlement summary

​
makerMatches
object[]

Maker matches if order was matched immediately