> ## Documentation Index
> Fetch the complete documentation index at: https://docs.olympex.io/llms.txt
> Use this file to discover all available pages before exploring further.

# List limit orders

> List the limit orders created with your API key, filtered by status, chain or maker wallet.

`GET /limit-order` returns every limit order created with your API key, including cancelled ones. Filter by `status`, `chainId` and `accountTo` to show a wallet's open orders, or to find out whether a [create call](/api-reference/limit-orders/create-limit-order) that timed out went through before you send it again.

Signed endpoint with no request body. Sign the method, the path and the empty string (`bodyHash` `47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU`), send no body, and send `Content-Type: application/json` and the four headers `x-api-key-id`, `x-value-info`, `x-passphrase` and `x-signature` described in [Sign requests](/authentication/sign-requests). The query string is signed in canonical form: parameters sorted by key, then by value, percent-encoded per RFC 3986. Optional query parameters, combined with AND: `status` (`pending`, `executing`, `submitted`, `completed`, `cancelled` or `failed`), `chainId` (an integer such as `137`) and `accountTo` (an exact, case-sensitive match). Other query parameters are ignored, and a repeated parameter matches nothing. `data` is an array of limit orders, unsorted and unpaginated, holding only orders created with the API key that signs the request.

## Filters

| Query parameter | Returns only orders |
| - | - |
| `status` | With this status: `pending`, `executing`, `submitted`, `completed`, `cancelled` or `failed`. |
| `chainId` | On this chain, for example `137`. |
| `accountTo` | For this maker wallet, written exactly as it was sent when the order was created. The match is case-sensitive, so always send the EIP-55 checksummed form, both when you create orders and when you filter. |

Filters combine with AND. Without filters, the response holds every limit order created with your API key. There is no pagination: other query parameters, such as `limit` or `offset`, are ignored. So is a misspelt filter, so check the spelling: `?acountTo=` returns every order. Send each parameter once: a repeated parameter matches nothing and returns an empty array. Filter values aren't validated either: an unknown `status`, or a `chainId` that isn't a number, returns an empty array, not an error.

## What the list holds

* **Only your orders.** The list holds the orders created with the API key that signs the request. Orders created with another API key never appear, and their IDs return `404` on [`GET /limit-order/{id}`](/api-reference/limit-orders/get-limit-order).
* **Cancelled orders too.** A cancelled order stays in the list with `status: "cancelled"` and `deletedAt` set. To show open orders, filter with `status=pending`, or keep the orders whose `status` isn't final (`completed`, `failed` or `cancelled`).
* **Unsorted and unpaginated.** Sort by `createdAt` yourself. Every matching order comes back in one response, so narrow the list with `accountTo` and `status` instead of fetching every order on each poll.
* **Numbers and normalized symbols.** `amount`, `price` and `priceTrigger` come back as JSON numbers, and `tokenASymbol` and `tokenBSymbol` can be normalized (`WETH` comes back as `ETH`). Identify orders by token address, never by symbol.

## Find an order after a create call timed out

`POST /limit-order` creates a new order every time it succeeds, so never resend a create call that timed out without checking first. List the maker's orders on the chain and look for one that matches the body you sent. `expired` comes back exactly as you sent it, which makes it a practical field to match on.

```ts theme={null}
import { olympexRequest } from "./sign-request.ts"; // /authentication/sign-requests

type LimitOrder = { id: string; inTokenAddress: string; outTokenAddress: string; amount: number; priceTrigger: number; expired: string };

// Fields from the body of the POST /limit-order call that timed out.
const sent = {
  accountTo: "0x1E67cb01969D79B2B895179e4A07D24a839dBb52",
  inTokenAddress: "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619", // WETH
  outTokenAddress: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", // USDC
  amount: "0.5",
  priceTrigger: "4200",
  expired: "1791302400000",
};

const sameAddress = (a: string, b: string) => a.toLowerCase() === b.toLowerCase();
const query = new URLSearchParams({ accountTo: sent.accountTo, chainId: "137" });
const orders = await olympexRequest<LimitOrder[]>("GET", `/limit-order?${query}`);
const existing = orders.find(
  (order) =>
    order.expired === sent.expired &&
    sameAddress(order.inTokenAddress, sent.inTokenAddress) &&
    sameAddress(order.outTokenAddress, sent.outTokenAddress) &&
    order.amount === Number(sent.amount) &&
    order.priceTrigger === Number(sent.priceTrigger),
);
console.log(existing ? `Already created: ${existing.id}` : "Not created: sign the create call again and send it");
```

<RequestExample>
  ```bash cURL theme={null}
  # List the pending limit orders of one maker wallet.
  # Needs openssl, curl and OLYMPEX_API_KEY_ID, OLYMPEX_SECRET_KEY, OLYMPEX_PASSPHRASE.
  METHOD=GET
  ENDPOINT=/limit-order
  QUERY='accountTo=0x1E67cb01969D79B2B895179e4A07D24a839dBb52&status=pending'
  BODY='' # GET has no body: the signature covers the empty string
  TS="${OLYMPEX_TIMESTAMP:-$(date +%s)}"
  NONCE="${OLYMPEX_NONCE:-$(openssl rand -hex 12)}"
  BODY_HASH="$(printf '%s' "$BODY" | openssl dgst -sha256 -binary | openssl base64 -A | tr '+/' '-_' | tr -d '=')"
  VALUE_INFO="$(printf '%s\n%s\n%s' "$TS" "$NONCE" "$BODY_HASH")"
  MESSAGE="$(printf 'OLPX-HMAC-SHA256-V2\n%s\n%s\n%s\n%s\n%s\n%s' "$TS" "$NONCE" "$METHOD" "/api/v1$ENDPOINT" "$QUERY" "$BODY_HASH")"
  curl -sS -X "$METHOD" "https://api-rest.olympex.io/api/v1$ENDPOINT${QUERY:+?$QUERY}" \
    -H "content-type: application/json" \
    -H "x-api-key-id: $OLYMPEX_API_KEY_ID" \
    -H "x-value-info: $(printf '%s' "$VALUE_INFO" | openssl base64 -A)" \
    -H "x-passphrase: $OLYMPEX_PASSPHRASE" \
    -H "x-signature: $(printf '%s' "$MESSAGE" | openssl dgst -sha256 -hmac "$OLYMPEX_SECRET_KEY" -binary | od -An -v -tx1 | tr -d ' \n')"
  ```

  ```ts TypeScript theme={null}
  import { olympexRequest } from "./sign-request.ts"; // /authentication/sign-requests

  type LimitOrder = { id: string; status: string; amount: number; priceTrigger: number; tokenASymbol: string; tokenBSymbol: string; createdAt: string };

  const maker = "0x1E67cb01969D79B2B895179e4A07D24a839dBb52"; // EIP-55 form, as sent when the orders were created
  const query = new URLSearchParams({ accountTo: maker, chainId: "137", status: "pending" });
  const orders = await olympexRequest<LimitOrder[]>("GET", `/limit-order?${query}`);

  orders.sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt)); // the list is unsorted
  for (const order of orders) {
    console.log(order.id, `sell ${order.amount} ${order.tokenASymbol} at ${order.priceTrigger} ${order.tokenBSymbol}`);
  }
  ```

  ```python Python theme={null}
  from urllib.parse import urlencode

  from sign_request import olympex_request  # /authentication/sign-requests

  maker = "0x1E67cb01969D79B2B895179e4A07D24a839dBb52"  # EIP-55 form, as sent when the orders were created
  query = urlencode({"accountTo": maker, "chainId": 137, "status": "pending"})
  orders = olympex_request("GET", f"/limit-order?{query}")

  for order in sorted(orders, key=lambda o: o["createdAt"]):  # the list is unsorted
      print(order["id"], f'sell {order["amount"]} {order["tokenASymbol"]} at {order["priceTrigger"]} {order["tokenBSymbol"]}')
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "success": true,
    "data": [
      {
        "id": "afc47108-d059-473c-b2e1-5f2ca7951466",
        "accountTo": "0x1E67cb01969D79B2B895179e4A07D24a839dBb52",
        "chainId": 137,
        "gasPrice": "35",
        "inTokenAddress": "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619",
        "outTokenAddress": "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
        "slippage": "1",
        "tokenASymbol": "ETH",
        "tokenBSymbol": "USDC",
        "amount": 0.5,
        "price": 4200,
        "priceTrigger": 4200,
        "expired": "1791302400000",
        "txHash": "",
        "status": "pending",
        "reasonFail": [],
        "attemptNumber": 0,
        "allowance": "",
        "estimateGas": "",
        "effectivePriceGas": "",
        "createdAt": "2026-09-29T16:01:22.237Z",
        "updatedAt": "2026-09-29T16:01:22.237Z",
        "deletedAt": ""
      }
    ],
    "meta": {
      "requestId": "EdkfMgWMIAMEPrQ=",
      "version": "v1",
      "accountType": "integrator",
      "apiKeyId": "00000000-0000-4000-8000-000000000000"
    }
  }
  ```

  ```json 403 Gateway theme={null}
  {
    "message": "Forbidden"
  }
  ```
</ResponseExample>


## OpenAPI

````yaml api-reference/openapi.json GET /limit-order
openapi: 3.0.3
info:
  title: Olympex REST API
  version: 1.0.0
  description: >-
    Aggregated swap quotes and transactions, limit orders and DCA strategies on
    EVM chains, plus the chain and token catalog. Every response uses the same
    envelope, except the API gateway's own responses (`{"message": …}`): `401`
    or `403` when the signed headers are missing or rejected, `429` when it
    throttles requests, and `500` or `503` when it can't get a response from
    Olympex in time. Chain IDs are integers on every endpoint. Signed endpoints
    require four signed headers; see [Sign
    requests](https://docs.olympex.io/authentication/sign-requests).
  termsOfService: https://docs.olympex.io/legal/terms
  contact:
    name: Olympex partnerships
    email: partners@olympex.io
    url: https://docs.olympex.io
servers:
  - url: https://api-rest.olympex.io/api/v1
    description: Olympex REST API v1
security: []
tags:
  - name: Accounts
    description: Create API credentials.
  - name: Quotes
    description: Aggregated single-chain and cross-chain quotes.
  - name: Swap
    description: Unsigned transaction calldata for a quoted route.
  - name: TxStatus
    description: Track a cross-chain transfer after you broadcast it.
  - name: Transactions
    description: On-chain status of a transaction you broadcast.
  - name: Chains and tokens
    description: Enabled chains and the tokens listed on each.
  - name: Limit orders
    description: Orders that Olympex executes when the market reaches your price.
  - name: DCA
    description: Strategies that buy a token in equal orders over time.
  - name: Docs
    description: Machine-readable API description.
paths:
  /limit-order:
    get:
      tags:
        - Limit orders
      summary: List limit orders
      description: >-
        Returns the limit orders created with your API key, including cancelled
        ones. Filters combine with AND. The list is unsorted and unpaginated. No
        request body: sign the empty string. The query string is signed in
        canonical form.
      operationId: listLimitOrders
      parameters:
        - name: accountTo
          in: query
          required: false
          schema:
            type: string
          description: >-
            Only orders for this maker wallet. Matches case-sensitively: use the
            exact form you sent when you created the order.
          example: '0x1E67cb01969D79B2B895179e4A07D24a839dBb52'
        - name: chainId
          in: query
          required: false
          schema:
            type: integer
            minimum: 1
          description: >-
            Only orders on this chain: an integer such as `137`. A value that
            isn't an integer matches nothing and returns an empty array.
          example: 137
        - name: status
          in: query
          required: false
          schema:
            type: string
            enum:
              - pending
              - executing
              - submitted
              - completed
              - cancelled
              - failed
          description: Only orders with this status.
      responses:
        '200':
          description: Matching limit orders.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/LimitOrderListSuccessResponse'
              example:
                success: true
                data:
                  - id: afc47108-d059-473c-b2e1-5f2ca7951466
                    accountTo: '0x1E67cb01969D79B2B895179e4A07D24a839dBb52'
                    chainId: 137
                    gasPrice: '35'
                    inTokenAddress: '0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619'
                    outTokenAddress: '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359'
                    slippage: '1'
                    tokenASymbol: ETH
                    tokenBSymbol: USDC
                    amount: 0.5
                    price: 4200
                    priceTrigger: 4200
                    expired: '1791302400000'
                    txHash: ''
                    status: pending
                    reasonFail: []
                    attemptNumber: 0
                    allowance: ''
                    estimateGas: ''
                    effectivePriceGas: ''
                    createdAt: '2026-09-29T16:01:22.237Z'
                    updatedAt: '2026-09-29T16:01:22.237Z'
                    deletedAt: ''
                meta:
                  requestId: EdkfMgWMIAMEPrQ=
                  version: v1
                  accountType: integrator
                  apiKeyId: 00000000-0000-4000-8000-000000000000
        '401':
          description: >-
            A signing header is missing. The gateway answers with
            `{"message":"Unauthorized"}` before your request reaches Olympex;
            the handler answers with the `UNAUTHORIZED` envelope when the
            authorizer context is missing.
          content:
            application/json:
              schema:
                oneOf:
                  - $ref: '#/components/schemas/GatewayError'
                  - $ref: '#/components/schemas/ErrorResponse'
              example:
                message: Unauthorized
        '403':
          description: >-
            Authentication failed: unknown key, wrong passphrase, invalid
            signature, timestamp outside the ±300 s window, reused nonce, or
            inactive account (gateway `{"message":"Forbidden"}`). The handler
            answers with the `FORBIDDEN` envelope when the signed `bodyHash` is
            not the hash of an empty body.
          content:
            application/json:
              schema:
                oneOf:
                  - $ref: '#/components/schemas/GatewayError'
                  - $ref: '#/components/schemas/ErrorResponse'
              examples:
                gateway:
                  summary: Signature rejected by the gateway
                  value:
                    message: Forbidden
                bodyHash:
                  summary: Body does not match the signed hash
                  value:
                    success: false
                    error:
                      code: FORBIDDEN
                      message: Invalid body hash
                      details: []
                    meta:
                      requestId: ENXGDhsXIAMEMEw=
                      version: v1
                      accountType: integrator
                      apiKeyId: 00000000-0000-4000-8000-000000000000
        '404':
          description: >-
            Unknown path or wrong method (`NOT_FOUND`). `error.message` names
            the method and path.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                success: false
                error:
                  code: NOT_FOUND
                  message: No route for GET /api/v1/quote
                  details: []
                meta:
                  requestId: E7edogG4IAMEPYA=
                  version: v1
        '500':
          description: >-
            Olympex could not complete the request (`INTERNAL_ERROR`), or the
            gateway could not get a response (`{"message":"Internal Server
            Error"}`), which also happens on the first request after a quiet
            period. Retry with backoff.
          content:
            application/json:
              schema:
                oneOf:
                  - $ref: '#/components/schemas/ErrorResponse'
                  - $ref: '#/components/schemas/GatewayError'
              example:
                success: false
                error:
                  code: INTERNAL_ERROR
                  message: Unexpected internal error
                  details: []
                meta:
                  requestId: EdkfMgWMIAMEPrQ=
                  version: v1
                  accountType: integrator
                  apiKeyId: 00000000-0000-4000-8000-000000000000
        '503':
          description: >-
            The gateway could not get a response in time (the integration
            timeout is about 30 seconds) or the service is briefly unavailable.
            Returned by the gateway. Retry with backoff.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GatewayError'
              example:
                message: Service Unavailable
      security:
        - ApiKeyId: []
          ValueInfo: []
          Passphrase: []
          Signature: []
components:
  schemas:
    LimitOrderListSuccessResponse:
      type: object
      required:
        - success
        - data
        - meta
      properties:
        success:
          type: boolean
          enum:
            - true
        data:
          type: array
          items:
            $ref: '#/components/schemas/LimitOrder'
          description: >-
            Every limit order created with this API key that matches the
            filters, including cancelled ones. Unsorted and unpaginated: sort by
            `createdAt` yourself.
        meta:
          $ref: '#/components/schemas/Meta'
    GatewayError:
      type: object
      required:
        - message
      description: >-
        Returned by the API gateway itself: `401` or `403` when the signed
        headers are missing or rejected, `429` when it throttles requests, and
        `500` or `503` when it can't get a response from Olympex in time. It has
        no `success`, `error` or `meta`.
      properties:
        message:
          type: string
          example: Forbidden
    ErrorResponse:
      type: object
      required:
        - success
        - error
        - meta
      properties:
        success:
          type: boolean
          enum:
            - false
        error:
          $ref: '#/components/schemas/ErrorBody'
        meta:
          $ref: '#/components/schemas/Meta'
    LimitOrder:
      type: object
      description: A limit order. Olympex can add fields; ignore the ones you don't use.
      required:
        - id
        - accountTo
        - chainId
        - inTokenAddress
        - outTokenAddress
        - tokenASymbol
        - tokenBSymbol
        - amount
        - price
        - priceTrigger
        - expired
        - slippage
        - gasPrice
        - status
        - txHash
        - reasonFail
        - attemptNumber
        - createdAt
        - updatedAt
        - deletedAt
      properties:
        id:
          type: string
          format: uuid
          description: Order ID.
        accountTo:
          type: string
          description: Maker wallet, as sent when the order was created.
        chainId:
          type: integer
          description: Chain ID.
        inTokenAddress:
          type: string
          description: Token sold, as sent.
        outTokenAddress:
          type: string
          description: Token bought, as sent.
        tokenASymbol:
          type: string
          description: >-
            Symbol of the token sold, possibly normalized (`WETH` becomes
            `ETH`).
        tokenBSymbol:
          type: string
          description: Symbol of the token bought, possibly normalized.
        amount:
          type: number
          description: Amount of the token sold, human-readable.
        price:
          type: number
          description: Copy of the limit price. `0` when it wasn't sent.
        priceTrigger:
          type: number
          description: 'Limit price: units of the token bought per 1 token sold.'
        expired:
          type: string
          description: 'Expiry as sent: a Unix timestamp in milliseconds.'
        slippage:
          type: string
          description: Maximum slippage, in percent.
        gasPrice:
          type: string
          description: >-
            Gas price, in gwei, as sent. Olympex stores it with the order, but
            execution uses the chain's gas price at that moment, so it isn't a
            cap.
        status:
          type: string
          enum:
            - pending
            - executing
            - submitted
            - completed
            - cancelled
            - failed
          description: >-
            `pending`: waiting for the price. `executing` and `submitted`:
            Olympex is executing it. `completed`: executed, see `txHash`.
            `cancelled`: cancelled. `failed`: execution failed, see
            `reasonFail`. Treat any other value as not final.
        txHash:
          type: string
          description: >-
            Execution transaction hash on `chainId`. Empty until the order
            executes.
        reasonFail:
          type: array
          items:
            type: string
          description: Why execution failed, when it did. Empty otherwise.
        attemptNumber:
          type: integer
          description: How many times Olympex has tried to execute the order.
        allowance:
          type: string
          description: >-
            Informational, reserved for Olympex: you can't set it. Usually an
            empty string.
        estimateGas:
          type: string
          description: >-
            Informational, reserved for Olympex: you can't set it. Usually an
            empty string.
        effectivePriceGas:
          type: string
          description: >-
            Informational, reserved for Olympex: you can't set it. Usually an
            empty string.
        createdAt:
          type: string
          format: date-time
          description: When the order was created (ISO 8601, UTC).
        updatedAt:
          type: string
          format: date-time
          description: When the order last changed (ISO 8601, UTC).
        deletedAt:
          type: string
          description: >-
            When the order was cancelled with `DELETE` (ISO 8601, UTC). An empty
            string until then.
    Meta:
      type: object
      required:
        - requestId
        - version
      properties:
        requestId:
          type: string
          description: Unique ID for this request. Include it when you contact support.
        version:
          type: string
          default: v1
          description: API version that served the request.
        accountType:
          type: string
          description: >-
            Account type resolved by the signature check, for example
            `integrator`. Present when the request was authenticated; absent on
            the `404` for an unknown path or method.
        apiKeyId:
          type: string
          format: uuid
          description: >-
            The API key ID that signed the request. Present when the request was
            authenticated; absent on the `404` for an unknown path or method.
    ErrorBody:
      type: object
      required:
        - code
        - message
        - details
      properties:
        code:
          type: string
          description: >-
            Machine-readable error code. `VALIDATION_ERROR` (400),
            `UNAUTHORIZED` (401), `FORBIDDEN` (403), `NOT_FOUND` (404, also for
            an unknown path or method), `CONFLICT` (409), `NO_ROUTE` (422), and
            for 500: `QUOTE_ERROR`, `CROSS_CHAIN_QUOTE_ERROR`, `SWAP_ERROR`,
            `CROSS_CHAIN_SWAP_ERROR`, `SUPPORT_CHAIN_ERROR`,
            `ENABLED_CHAINS_ERROR`, `TOKEN_LIST_ERROR`, `TX_STATUS_ERROR`,
            `INTERNAL_ERROR`. Olympex can add codes: handle an unknown code by
            its HTTP status.
        message:
          type: string
          description: Human-readable summary. Don't parse it.
        details:
          type: array
          items:
            $ref: '#/components/schemas/ErrorDetail'
    ErrorDetail:
      type: object
      additionalProperties: true
      description: >-
        Validation errors carry `field` and `message`; other errors carry
        `message` only.
      properties:
        field:
          type: string
          description: >-
            Dot path of the invalid field, for example `params.chainId`. Empty
            for the top level.
        message:
          type: string
  securitySchemes:
    ApiKeyId:
      type: apiKey
      in: header
      name: x-api-key-id
      description: >-
        Your API key ID (UUID). See [Sign
        requests](https://docs.olympex.io/authentication/sign-requests).
    ValueInfo:
      type: apiKey
      in: header
      name: x-value-info
      description: >-
        Base64 of `timestamp + "\n" + nonce + "\n" + bodyHash`, where
        `timestamp` is Unix seconds, `nonce` is 24 new hexadecimal characters
        and `bodyHash` is the unpadded base64url SHA-256 of the canonical body.
    Passphrase:
      type: apiKey
      in: header
      name: x-passphrase
      description: Your account passphrase. Treat it like the secret key.
    Signature:
      type: apiKey
      in: header
      name: x-signature
      description: >-
        Lowercase hex HMAC-SHA256 (signature v2), keyed with your secret key
        string (UTF-8, not decoded), of seven lines joined with `\n`, with no
        trailing newline: `OLPX-HMAC-SHA256-V2`, `timestamp`, `nonce`, the
        uppercase method, `path`, `canonicalQuery` and `bodyHash`. `path` is the
        request path including `/api/v1`, without the query string, for example
        `/api/v1/limit-order/<id>`. `canonicalQuery` is the query parameters
        decoded (`+` is a space), sorted by key and then by value, re-encoded
        per RFC 3986 and joined with `&`, or the empty string when there is no
        query. Headers signed for one request are rejected on any other. See
        [Sign requests](https://docs.olympex.io/authentication/sign-requests).

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.