Limit order API integration

Place a gasless, MEV-protected limit order over the REST API. A limit order is a Delta order with a target-price constraint: build with limitAmount, submit with type=LIMIT, end-to-end.

A limit order on Velora is a Delta order with a target-price constraint: the user signs once, the Portikus Network fills it at or better than the limit price when the market allows, and the user pays no gas. This page walks the whole integration over the REST API. It’s the Delta swap flow with two additions: you set limitAmount at build, and submit with type: "LIMIT". Every example targets https://api.velora.xyz.

For the conceptual model (maker, expiry, how a limit order differs from a swap or OTC), see Product stack → Limit orders. For a typed wrapper, see SDK → Limit orders.

The flow

1. Quote a reference price

   GET /v2/quote?mode=DELTA gives the current route and the spender to approve. The market quote is your reference point for setting the limit. See GET /v2/quote.

2. Approve the spender

   Approve the Delta contract spender on-chain for the source token. Limit orders use approval, not a permit; see Approvals and permit. Native source skips this; see Native ETH (dETH).

3. Build with a limit price

   POST /v2/delta/orders/build with the route verbatim, owner, a deadline, and limitAmount (your target output for SELL, or max input for BUY). See POST /v2/delta/orders/build.

4. Sign and submit as LIMIT

   The user signs toSign; POST /v2/delta/orders with type: "LIMIT". See POST /v2/delta/orders.

5. Poll, or drive your UI from the order list

   A limit order rests ACTIVE until a solver can meet the price, so poll on a relaxed interval or list the user’s open orders.

1. Quote and approve

Quote exactly as for a Delta swap (mode=DELTA), then approve the returned spender for the source token. Use the quote’s expected output as the baseline for the limit price you’ll pin in the next step. Approve on-chain rather than with a permit, which a resting order can’t rely on (see Approvals and permit). Selling native ETH skips the approval; see Native ETH (dETH).

2. Build with a limit price

Pass the delta.route verbatim and add limitAmount. For a SELL order it’s the minimum destination amount you’ll accept (your limit price). Every Delta order requires a deadline (unix seconds); past it the order is unfillable.

curl -X POST 'https://api.velora.xyz/v2/delta/orders/build' \
  -H 'Content-Type: application/json' \
  -d '{
    "route": { "...": "the delta.route from the quote, unchanged" },
    "owner": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
    "limitAmount": "3000000000000000000",
    "deadline": 1893456000,
    "partner": "my-app-name"
  }'

Setting limitAmount above the quoted output is what makes this a limit order rather than a market fill: the solver network only fills once it can deliver at least that much. The response is the same { toSign, orderHash } as a market order.

3. Submit as LIMIT

The user signs toSign (ERC-2098 compact signature). Submit with type: "LIMIT". That field is what marks the order as a resting limit order instead of an immediate fill:

curl -X POST 'https://api.velora.xyz/v2/delta/orders' \
  -H 'Content-Type: application/json' \
  -d '{
    "chainId": 1,
    "order": { "...": "toSign.value, sent verbatim" },
    "signature": "0x...",
    "type": "LIMIT",
    "partner": "my-app-name"
  }'

4. List and cancel

List a user’s open limit orders by filtering on type:

curl -G 'https://api.velora.xyz/v2/delta/orders' \
  --data-urlencode 'userAddress=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045' \
  --data-urlencode 'chainId=1' \
  --data-urlencode 'type=LIMIT' \
  --data-urlencode 'page=1' \
  --data-urlencode 'limit=100'

To check one order, GET /v2/delta/orders/{orderId}, or open it in the Velora explorer at https://explorer.velora.xyz/order/{orderId} for a human-readable status view. That’s useful for a resting limit order that may sit ACTIVE for a while.

Cancelling is gasless. Build the cancellation payload, have the user sign the returned toSign object, then post the same order IDs with the signature. It only succeeds while the order is still open or executing.

curl -X POST 'https://api.velora.xyz/v2/delta/orders/build/cancellation' \
  -H 'Content-Type: application/json' \
  -d '{ "orderIds": ["..."] }'

curl -X POST 'https://api.velora.xyz/v2/delta/orders/cancel' \
  -H 'Content-Type: application/json' \
  -d '{ "orderIds": ["..."], "signature": "0x..." }'

See GET /v2/delta/orders, POST /v2/delta/orders/build/cancellation, and POST /v2/delta/orders/cancel.

Partner fee

Pass partner on the quote, build, and submit calls (plus optional partnerAddress, partnerFeeBps, partnerTakesSurplus), exactly as for a Delta swap. See Monetize.

Related pages

• Delta swap: the base flow a limit order extends.
• TWAP, the other scheduled Delta order type.
• Native ETH (dETH): selling native ETH as a Delta source.
• Product stack → Limit orders for the conceptual model.
• Delta API reference lists full parameters and response schemas.
• SDK → Limit orders, a typed wrapper over this flow.