# Purge Queue (/learn/queues/how-to/purge-queue)



<Callout type="warn">
  **Purging is irreversible.** All messages in the queue are permanently deleted. Use with caution in production environments.
</Callout>

## How Purge Works [#how-purge-works]

Purging a queue acknowledges every pending message at once, removing them from the channel. Consumers that poll afterward find the queue empty.

<Mermaid
  chart="graph LR
  Q{{&#x22;Queue channel<br/>orders&#x22;}}
  M1[&#x22;msg 1&#x22;]
  M2[&#x22;msg 2&#x22;]
  M3[&#x22;msg 3&#x22;]
  E{{&#x22;Queue channel<br/>orders (empty)&#x22;}}

  M1 --> Q
  M2 --> Q
  M3 --> Q
  Q -- &#x22;purge<br/>(ack all)&#x22; --> E

  class Q,E queue
  class M1,M2,M3 data"
/>

*Purge acknowledges all pending messages in a single call, leaving the channel empty.*

## When to Purge [#when-to-purge]

| Scenario         | Description                                   |
| ---------------- | --------------------------------------------- |
| **Development**  | Clear test messages between iterations        |
| **Testing**      | Reset queue state before test runs            |
| **Stuck queues** | Remove poison messages blocking consumers     |
| **Data cleanup** | Clear obsolete messages after a schema change |

## Purge All Messages [#purge-all-messages]

Purging is implemented as an "acknowledge all" operation on the channel — every pending message is acked at once and removed.

<Tabs groupId="language" items="['Go', 'Python', 'Node.js', 'Java', 'C#', 'Kotlin', 'C++', 'Rust', 'Ruby', 'Elixir']">
  <Tab value="Go">
    ```go title="purge.go"
    resp, err := client.AckAllQueueMessages(ctx, &kubemq.AckAllQueueMessagesRequest{
        Channel:         "orders",
        WaitTimeSeconds: 5,
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Purged %d messages from 'orders'\n", resp.AffectedMessages)
    ```
  </Tab>

  <Tab value="Python">
    ```python title="purge.py"
    acked = client.ack_all_queue_messages("orders", wait_time_seconds=5)
    print(f"Purged {acked} messages from 'orders'")
    ```
  </Tab>

  <Tab value="Node.js">
    ```typescript title="purge.ts"
    await client.purgeQueue('orders');
    console.log("Queue 'orders' purged successfully");
    ```
  </Tab>

  <Tab value="Java">
    ```java title="Purge.java"
    // purgeQueue is not yet exposed by the Java v2 SDK.
    // Purge by acknowledging all messages on the channel instead.
    QueuesPollResponse response = client.receiveQueueMessages(
        QueuesPollRequest.builder()
            .channel("orders")
            .pollMaxMessages(1024)
            .pollWaitTimeoutInSeconds(2)
            .autoAckMessages(true)
            .build());

    System.out.printf("Purged %d messages from 'orders'%n", response.getMessages().size());
    ```
  </Tab>

  <Tab value="C#">
    ```csharp title="Purge.cs"
    var result = await client.PurgeQueueAsync("orders");
    Console.WriteLine($"Purged {result.AffectedMessages} messages from 'orders'");
    ```
  </Tab>

  <Tab value="Kotlin">
    ```kotlin title="Purge.kt"
    val purged = client.purgeQueuesChannel("orders")
    println("Purged $purged messages from 'orders'")
    ```
  </Tab>

  <Tab value="C++">
    ```cpp title="purge.cpp"
    kubemq::AckAllQueueMessagesRequest req;
    req.channel = "orders";
    req.wait_time_seconds = 5;

    auto result = client->AckAllQueueMessages(req);
    if (result.ok() && !result->is_error) {
        std::cout << "Purged " << result->affected_messages << " messages from 'orders'" << std::endl;
    }
    ```
  </Tab>

  <Tab value="Rust">
    ```rust title="purge.rs"
    client.ack_all_queue_messages("orders").await?;
    println!("Queue 'orders' purged successfully");
    ```
  </Tab>

  <Tab value="Ruby">
    ```ruby title="purge.rb"
    client.purge_queue_channel(channel_name: 'orders')
    puts "Queue 'orders' purged successfully"
    ```
  </Tab>

  <Tab value="Elixir">
    ```elixir title="purge.exs"
    :ok = KubeMQ.Client.purge_queue_channel(client, "orders")
    IO.puts("Queue 'orders' purged successfully")
    ```
  </Tab>
</Tabs>

## Verify the Queue is Empty [#verify-the-queue-is-empty]

After purging, poll the queue to confirm no messages remain.

<Tabs groupId="language" items="['Go', 'Python', 'Node.js', 'Java', 'C#', 'Kotlin', 'C++', 'Rust', 'Ruby', 'Elixir']">
  <Tab value="Go">
    ```go title="verify_purge.go"
    resp, err := client.PollQueue(ctx, &kubemq.PollRequest{
        Channel:            "orders",
        MaxItems:           10,
        WaitTimeoutSeconds: 2,
        AutoAck:            true,
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Messages remaining: %d\n", len(resp.Messages))
    ```
  </Tab>

  <Tab value="Python">
    ```python title="verify_purge.py"
    response = client.receive_queue_messages(
        channel="orders",
        max_messages=10,
        wait_timeout_in_seconds=2,
        auto_ack=True,
    )
    print(f"Messages remaining: {len(response.messages)}")
    ```
  </Tab>

  <Tab value="Node.js">
    ```typescript title="verify_purge.ts"
    const remaining = await client.peekQueueMessages({
      channel: 'orders',
      maxMessages: 10,
      waitTimeoutSeconds: 2,
    });
    console.log(`Messages remaining: ${remaining.length}`);
    ```
  </Tab>

  <Tab value="Java">
    ```java title="VerifyPurge.java"
    QueuesPollResponse response = client.receiveQueueMessages(
        QueuesPollRequest.builder()
            .channel("orders")
            .pollMaxMessages(10)
            .pollWaitTimeoutInSeconds(2)
            .autoAckMessages(true)
            .build());

    System.out.printf("Messages remaining: %d%n", response.getMessages().size());
    ```
  </Tab>

  <Tab value="C#">
    ```csharp title="VerifyPurge.cs"
    var response = await client.ReceiveQueueMessagesAsync(new QueuePollRequest
    {
        Channel = "orders",
        MaxMessages = 10,
        WaitTimeoutSeconds = 2,
        AutoAck = true,
    });
    Console.WriteLine($"Messages remaining: {response.Messages.Count}");
    ```
  </Tab>

  <Tab value="Kotlin">
    ```kotlin title="VerifyPurge.kt"
    val response = client.peekQueueMessages {
        channel = "orders"
        maxNumberOfMessages = 10
        waitTimeSeconds = 2
    }
    println("Messages remaining: ${response.messages.size}")
    ```
  </Tab>

  <Tab value="C++">
    ```cpp title="verify_purge.cpp"
    kubemq::ReceiveQueueMessagesRequest req;
    req.channel = "orders";
    req.max_number_of_messages = 10;
    req.wait_time_seconds = 2;
    req.is_peek = true;

    auto response = client->ReceiveQueueMessages(req);
    std::cout << "Messages remaining: " << response->messages.size() << std::endl;
    ```
  </Tab>

  <Tab value="Rust">
    ```rust title="verify_purge.rs"
    // receive_queue_messages(channel, max_messages, wait_seconds, is_peek)
    let remaining = client.receive_queue_messages("orders", 10, 2, true).await?;
    println!("Messages remaining: {}", remaining.len());
    ```
  </Tab>

  <Tab value="Ruby">
    ```ruby title="verify_purge.rb"
    remaining = client.receive_queue_messages(
      channel: 'orders',
      max_messages: 10,
      wait_timeout_seconds: 2,
      peek: true,
    )
    puts "Messages remaining: #{remaining.size}"
    ```
  </Tab>

  <Tab value="Elixir">
    ```elixir title="verify_purge.exs"
    {:ok, poll} = KubeMQ.Client.poll_queue(client,
      channel: "orders",
      max_items: 10,
      wait_timeout: 2_000
    )
    IO.puts("Messages remaining: #{length(poll.messages)}")
    ```
  </Tab>
</Tabs>

## Next Steps [#next-steps]

<Cards>
  <Card title="Peek Messages" href="/learn/queues/tutorials/peek-messages" description="Inspect queue contents without consuming." />

  <Card title="Queue Reference" href="/learn/queues/reference" description="All queue operations and configuration." />
</Cards>