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

# Order Entry — Cancel Order

Order cancellation is performed over **WebSocket**.

* **Endpoint:** `wss://trade.qfex.com?api_key=YOUR_API_KEY`
* **Authenticate within 1 minute of connecting.**

## 1) Authenticate

Send this immediately after you connect:

```json theme={null}
{ "type": "auth", "params": { "hmac": { "public_key": "qfex_pub_xxxxx", "nonce": "c0ffee...", "unix_ts": 1760545414, "signature": "5f2e..." } } }
```

## 2) Cancel Order

You can cancel by **`order_id`**, **`client_order_id`**, **`twap_id`**, or **`client_twap_id`** by setting the `order_id` field and using `cancel_order_id_type` to specify how the value should be interpreted.

* `order_id` — always a **UUID v4** and **unique**. Cancels exactly one order.
* `client_order_id` — **not guaranteed unique**. Cancels **all orders for that symbol** that share this client order id.
* `twap_id` — server-generated TWAP id. Cancels the matching TWAP.
* `client_twap_id` — client-supplied TWAP id. Cancels the matching TWAP for that symbol.

### Cancel by order id (single order)

```json theme={null}
{
  "type": "cancel_order",
  "params": {
    "order_id": "REPLACE_WITH_ORDER_UUID_V4",
    "symbol": "AAPL-USD",
    "cancel_order_id_type": "order_id"
  }
}
```

### Cancel by client order id (may cancel multiple)

```json theme={null}
{
  "type": "cancel_order",
  "params": {
    "order_id": "my-client-oid-123",
    "symbol": "AAPL-USD",
    "cancel_order_id_type": "client_order_id"
  }
}
```

### Cancel by TWAP id

```json theme={null}
{
  "type": "cancel_order",
  "params": {
    "order_id": "0c7c8e4d-f67e-4aa5-9c64-36a1a622ac35",
    "symbol": "AAPL-USD",
    "cancel_order_id_type": "twap_id"
  }
}
```

### Cancel by client TWAP id

```json theme={null}
{
  "type": "cancel_order",
  "params": {
    "order_id": "rebalance-aapl-001",
    "symbol": "AAPL-USD",
    "cancel_order_id_type": "client_twap_id"
  }
}
```

## Parameters

| Field                  | Type   | Required | Description                                                                                                                     |
| ---------------------- | ------ | -------- | ------------------------------------------------------------------------------------------------------------------------------- |
| `order_id`             | string | Optional | UUID v4 of the order to cancel. Required if `cancel_order_id_type` = `"order_id"`. Cancels exactly one order.                   |
| `client_order_id`      | string | Optional | Client-specified ID to cancel orders. Required if `cancel_order_id_type` = `"client_order_id"`. May cancel multiple orders.     |
| `symbol`               | string | ✅        | Market symbol of the order(s) (e.g. `AAPL-USD`).                                                                                |
| `cancel_order_id_type` | enum   | ✅        | Must be one of `"order_id"`, `"client_order_id"`, `"twap_id"`, or `"client_twap_id"`. Tells the engine how to interpret the ID. |

> ⚠️ Notes:
>
> * Put the identifier value in the `order_id` field for all four modes. The engine uses `cancel_order_id_type` to decide whether that value is an order id, client order id, TWAP id, or client TWAP id.
> * `order_id` is always unique (UUID v4).
> * `client_order_id` is not guaranteed unique and may cancel multiple orders for the same symbol.
> * `twap_id` and `client_twap_id` are used to cancel TWAPs.
> * Responses will include [OrderStatus](/api-reference/enums#orderstatus) codes, e.g. `CANCELLED`, `NO_SUCH_ORDER`, or `REJECTED`.

## Sample Code

<CodeGroup>
  ```python python theme={null}
  # Python (websocket-client)
  # pip install websocket-client
  import json
  import websocket

  API_KEY = "YOUR_API_KEY"
  ORDER_ID = "REPLACE_WITH_ORDER_UUID_V4"          # for order_id flow
  CLIENT_OID = "my-client-oid-123"                 # for client_order_id flow

  def send(ws, obj):
      ws.send(json.dumps(obj))

  def on_open(ws):
      # 1) Authenticate
      # https://docs.qfex.com/websocket/channels/trade/authenticate#how-it-works
      send(ws, {"type": "auth", "params": { "hmac": { "public_key": "qfex_pub_xxxxx", "nonce": "c0ffee...", "unix_ts": 1760545414, "signature": "5f2e..." }}})

      # 2a) Cancel by order_id (exactly one order)
      send(ws, {
          "type": "cancel_order",
          "params": {
              "order_id": ORDER_ID,
              "symbol": "AAPL-USD",
              "cancel_order_id_type": "order_id"
          }
      })

      # 2b) Cancel by client_order_id (may cancel multiple)
      # send(ws, {
      #     "type": "cancel_order",
      #     "params": {
      #         "client_order_id": CLIENT_OID,
      #         "symbol": "AAPL-USD",
      #         "cancel_order_id_type": "client_order_id"
      #     }
      # })

  ws = websocket.WebSocketApp(
      "wss://trade.qfex.com?api_key=YOUR_API_KEY",
      on_open=on_open,
      on_message=lambda _, m: print(m),
      on_error=lambda _, e: print("Error:", e),
      on_close=lambda *_: print("Closed"),
  )
  ws.run_forever()
  ```

  ```javascript node theme={null}
  // Node.js (ws)
  // npm i ws
  const WebSocket = require("ws");

  const API_KEY = "YOUR_API_KEY";
  const ORDER_ID = "REPLACE_WITH_ORDER_UUID_V4"; // for order_id flow
  const CLIENT_OID = "my-client-oid-123"; // for client_order_id flow

  const ws = new WebSocket("wss://trade.qfex.com?api_key=YOUR_API_KEY");

  ws.on("open", () => {
    // 1) Authenticate
    ws.send(JSON.stringify({ type: "auth", params: { api_key: API_KEY } }));

    // 2a) Cancel by order_id (exactly one order)
    ws.send(
      JSON.stringify({
        type: "cancel_order",
        params: {
          order_id: ORDER_ID,
          symbol: "AAPL-USD",
          cancel_order_id_type: "order_id",
        },
      })
    );

    // 2b) Cancel by client_order_id (may cancel multiple)
    // ws.send(JSON.stringify({
    //   type: "cancel_order",
    //   params: {
    //     client_order_id: CLIENT_OID,
    //     symbol: "AAPL-USD",
    //     cancel_order_id_type: "client_order_id"
    //   }
    // }));
  });

  ws.on("message", (m) => console.log(m.toString()));
  ws.on("error", (e) => console.error("WS error:", e));
  ws.on("close", (code, reason) =>
    console.log("Closed:", code, reason?.toString())
  );
  ```

  ```go go theme={null}
  // Go (gorilla/websocket)
  // go get github.com/gorilla/websocket
  package main

  import (
  	"log"

  	"github.com/gorilla/websocket"
  )

  func mustWriteJSON(c *websocket.Conn, v any) {
  	if err := c.WriteJSON(v); err != nil {
  		log.Fatal("write:", err)
  	}
  }

  func main() {
  	c, _, err := websocket.DefaultDialer.Dial("wss://trade.qfex.com?api_key=YOUR_API_KEY", nil)
  	if err != nil {
  		log.Fatal("dial:", err)
  	}
  	defer c.Close()

  	// 1) Authenticate
  	mustWriteJSON(c, map[string]any{
  		"type": "auth",
  		"params": map[string]any{"hmac": map[string]any{"public_key": "qfex_pub_xxxxx", "nonce": "c0ffee...", "unix_ts": 1760545414, "signature": "5f2e..."}}
  	})

  	// 2a) Cancel by order_id (exactly one order)
  	mustWriteJSON(c, map[string]any{
  		"type": "cancel_order",
  		"params": map[string]any{
  			"order_id":             "REPLACE_WITH_ORDER_UUID_V4",
  			"symbol":               "AAPL-USD",
  			"cancel_order_id_type": "order_id",
  		},
  	})

  	// 2b) Cancel by client_order_id (may cancel multiple)
  	// mustWriteJSON(c, map[string]any{
  	// 	"type": "cancel_order",
  	// 	"params": map[string]any{
  	// 		"client_order_id":      "my-client-oid-123",
  	// 		"symbol":               "AAPL-USD",
  	// 		"cancel_order_id_type": "client_order_id",
  	// 	},
  	// })
  }
  ```

  ```java java theme={null}
  // Java (OkHttp WebSocket)
  // Gradle: implementation("com.squareup.okhttp3:okhttp:4.12.0")
  import java.util.concurrent.TimeUnit;
  import okhttp3.*;

  public class CancelOrderWs {
    public static void main(String[] args) {
      OkHttpClient client = new OkHttpClient.Builder()
          .pingInterval(20, TimeUnit.SECONDS)
          .build();

      Request req = new Request.Builder()
          .url("wss://trade.qfex.com?api_key=YOUR_API_KEY")
          .build();

      WebSocketListener li = new WebSocketListener() {
        @Override public void onOpen(WebSocket ws, Response r) {
          // 1) Authenticate
          ws.send("{\"type\": \"auth\", \"params\": { \"hmac\": { \"public_key\": \"qfex_pub_xxxxx\", \"nonce\": \"c0ffee...\..\", \"unix_ts\": 1760545414, \"signature\": \"5f2e...\" }}}");

          // 2a) Cancel by order_id (exactly one order)
          ws.send("{\"type\":\"cancel_order\",\"params\":{\"order_id\":\"REPLACE_WITH_ORDER_UUID_V4\",\"symbol\":\"AAPL-USD\",\"cancel_order_id_type\":\"order_id\"}}");

          // 2b) Cancel by client_order_id (may cancel multiple)
          // ws.send("{\"type\":\"cancel_order\",\"params\":{\"client_order_id\":\"my-client-oid-123\",\"symbol\":\"AAPL-USD\",\"cancel_order_id_type\":\"client_order_id\"}}");
        }

        @Override public void onMessage(WebSocket ws, String text) {
          System.out.println(text);
        }
        @Override public void onFailure(WebSocket ws, Throwable t, Response r) {
          System.err.println("WS error: " + t.getMessage());
        }
      };

      client.newWebSocket(req, li);

      try { Thread.sleep(Long.MAX_VALUE); } catch (InterruptedException ignored) {}
    }
  }
  ```
</CodeGroup>

## Example Response

Placing an order returns `ACK`. Cancelling it returns the same structure but with status `CANCELLED`.

```json theme={null}
{
  "order_response": {
    "order_id": "5b309929-206f-40ec-804d-cbe46e81afc1",
    "symbol": "AAPL-USD",
    "status": "CANCELLED",
    "quantity": 1.0,
    "price": 200.0,
    "take_profit": 0.0,
    "stop_loss": 0.0,
    "side": "BUY",
    "type": "LIMIT",
    "time_in_force": "GTC",
    "user_id": "0020ce8e-eaee-480e-8d7f-b9241d756ee5",
    "client_order_id": "",
    "quantity_remaining": 1.0,
    "trade_id": null
  }
}
```