Skip to main content
POST
Create an arbitrage order

Authorizations

Authorization
string
header
required

Bearer authentication header of the form Bearer <token>, where <token> is your auth token.

Body

application/json
hedge
CreateArbitrageOrderLeg · object
required

The hedging leg, placed once the primary leg fills. Fires immediately alongside the primary when both legs are market orders.

primary
CreateArbitrageOrderLeg · object
required

The leg placed first. Its fill triggers the hedge leg.

executionDurationMs
integer

Time budget for a sequential order in milliseconds, counted from its creation. The first step is sent at once; before each later step the pause is recomputed as the time left divided by the steps left plus one, so the steps spread evenly over the budget and the last step keeps a slot to execute. The slippage check, if any, runs after the pause and is cut short by the budget: when the budget runs out during the wait the order fails with Slippage timeout, when it runs out before a later step is sent the order ends canceled; the steps hedged so far stay open. Cannot be combined with stepDelayMs. Ignored when each leg has a single size. Max value is 1 week.

Required range: x <= 604800000
Example:

600000

hedgeFailurePolicy
enum<string>

What happens when the hedge leg fails after the primary filled. Only alertAndHold — leave the naked leg and mark the order failed — is supported today.

Available options:
alertAndHold
maxSlippage
object

Slippage check applied before each step is sent. Without this object no check is made.

partialFillPolicy
enum<string>

When a partially filled primary leg gets hedged. Only fullFill — hedge after the primary leg fills completely — is supported today.

Available options:
fullFill
stepDelayMs
integer

Pause between steps in milliseconds. Once a step is hedged, the next step waits this long before its primary leg is sent; the slippage check, if any, runs after the pause. Ignored when each leg has a single size. Max value is 1 week.

Required range: x <= 604800000
Example:

5000

Response

cancelReason
enum<string> | null
required

Why the order was canceled. manual — canceled by request; auto_close — canceled by an auto-close order that flattened one of its markets; execution_duration_exceeded — executionDurationMs ran out before a step was sent. Null unless a cancel was requested.

Available options:
auto_close,
execution_duration_exceeded,
manual
Example:

"manual"

createdAt
string<date-time>
required

When the order was accepted.

Pattern: ^(?:(?:\d\d[2468][048]|\d\d[13579][26]|\d\d0[48]|[02468][048]00|[13579][26]00)-02-29|\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\d|30)|(?:02)-(?:0[1-9]|1\d|2[0-8])))T(?:(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z))$
executionDurationMs
integer | null
required

Time budget for the steps in milliseconds, counted from createdAt, or null when no budget was given. Ignored when the order has a single step.

Required range: 0 < x <= 9007199254740991
finishedAt
string<date-time> | null
required

When the order reached a terminal state. For finished orders this is the moment the last step was hedged, so it doubles as the position start time.

Pattern: ^(?:(?:\d\d[2468][048]|\d\d[13579][26]|\d\d0[48]|[02468][048]00|[13579][26]00)-02-29|\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\d|30)|(?:02)-(?:0[1-9]|1\d|2[0-8])))T(?:(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z))$
hedgeFailurePolicy
enum<string>
required

What happens when the hedge leg fails after the primary filled. alertAndHold — the naked leg is left in place and the order is marked failed. autoUnwind — the primary leg is closed with a market order.

Available options:
alertAndHold,
autoUnwind
Example:

"alertAndHold"

hedgeStepSizes
string[]
required

Size of the hedge leg for each step, in base units. The array length is the number of steps in the order.

Example:
id
string<uuid>
required

Arbitrage order identifier.

Pattern: ^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$
Example:

"019d5cbe-6980-7193-a80e-38a45eda36d8"

legsByStep
ArbitrageOrderStep · object[]
required

Steps reached so far with both legs, in execution order. The next step appears once the current one is hedged, so the array is shorter than primaryStepSizes while a sequential order is processing.

maxSlippageBps
string | null
required

Slippage limit in basis points that both legs must fit into before each step is sent, or null when no check is made.

Pattern: \d+(\.\d+)?
Example:

"0.001"

maxSlippageWaitMs
integer | null
required

How long a step waits for the slippage to fit, in milliseconds, before the order is marked failed. Null when no slippage check is made.

Required range: 0 < x <= 9007199254740991
partialFillPolicy
enum<string>
required

When a partially filled primary leg gets hedged. fullFill — only after the primary leg fills completely. immediate — every fill is hedged as it arrives. threshold — hedged once unhedged size crosses a threshold.

Available options:
fullFill,
immediate,
threshold
Example:

"fullFill"

primaryStepSizes
string[]
required

Size of the primary leg for each step, in base units. The array length is the number of steps in the order.

Example:
status
enum<string>
required

processing — the order is working: the current step is being placed, filled and hedged, or waits out stepDelayMs or its share of executionDurationMs before it is placed, and on a multi-step order every earlier step is already hedged and open. Follow the legs of the current step to see where it stands. canceling — a cancel was requested: no new step starts and the order of the current step is being canceled on the exchange; the order then ends canceled, or failed when the exchange rejects the cancel. finished — every step is hedged, both legs are open and the order is finalized. canceled — the steps that had not started were canceled, cancelReason says why; every step hedged before that stays open as a position. failed — needs manual handling; the legs may be directionally exposed.

Available options:
canceled,
canceling,
failed,
finished,
processing
Example:

"processing"

stepDelayMs
integer | null
required

Pause between steps in milliseconds, or null when each step starts as soon as the previous one is hedged.

Required range: 0 < x <= 9007199254740991
strategy
enum<string>
required

Leg types in execution order. marketMarket — both legs fire immediately. limitMarket — primary limit rests, hedge hedges with a market order once it fills. limitLimit — both legs are limit orders.

Available options:
limitLimit,
limitMarket,
marketMarket
Example:

"limitMarket"

unifiedSymbol
string
required

Cross-exchange asset key — an alias (alias:1000bonk) when defined, otherwise the base symbol.

Example:

"ETH"

updatedAt
string<date-time>
required

When the order last changed.

Pattern: ^(?:(?:\d\d[2468][048]|\d\d[13579][26]|\d\d0[48]|[02468][048]00|[13579][26]00)-02-29|\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\d|30)|(?:02)-(?:0[1-9]|1\d|2[0-8])))T(?:(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z))$