# Delete Channel (/sdks/go/how-to/management/delete-channel)



## Overview [#overview]

Deleting a channel is how you decommission a topic, queue, or RPC endpoint you no longer need — tearing down test fixtures between CI runs, retiring a deprecated integration, or cleaning up the throwaway channels a demo or load test created. It's a permanent, immediate operation: the channel's routing entry is removed from the broker and any messages still sitting in it are discarded, so it's not something you want triggered by a typo in a shared environment.

Under the hood, `client.DeleteChannel(ctx, name, channelType)` sends a management call that removes the channel by name and type; the typed convenience wrapper `client.DeleteEventsChannel(ctx, name)` does the same thing without requiring the `ChannelTypeEvents` constant. The `channelType` argument matters — channels are namespaced by type, so an events channel and a queues channel can share the same name without colliding, and deleting one never touches the other.

**Gotchas:** deleting a channel that doesn't exist returns an error rather than succeeding silently, so idempotent cleanup code needs to catch and ignore the not-found case. There's no "soft delete" or recovery window — once it's gone, any messages still queued are gone with it. And subscribers or producers still connected to a deleted channel won't be notified proactively; they'll only discover it on their next publish or receive call.

## Prerequisites [#prerequisites]

* KubeMQ server running on `localhost:50000`
* Go SDK installed (`go get github.com/kubemq-io/kubemq-go/v2`)

## Code [#code]

```go title="main.go"
// Example: management/delete-channel
//
// Demonstrates deleting a channel. First creates a channel, then deletes it.
//
// Channel: go-management.delete-channel
// Client ID: go-management-delete-channel-client
//
// Run with a KubeMQ server on localhost:50000
// (see https://docs.kubemq.io/deploy).
package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/kubemq-io/kubemq-go/v2"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	client, err := kubemq.NewClient(ctx,
		kubemq.WithAddress("localhost", 50000),
		kubemq.WithClientId("go-management-delete-channel-client"),
	)
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()

	channelName := "go-management.delete-channel.temp"

	// Create a channel to demonstrate deletion.
	err = client.CreateChannel(ctx, channelName, kubemq.ChannelTypeEvents)
	if err != nil {
		log.Printf("CreateChannel: %v", err)
	} else {
		fmt.Printf("Created channel: %s\n", channelName)
	}

	// Delete the channel.
	err = client.DeleteChannel(ctx, channelName, kubemq.ChannelTypeEvents)
	if err != nil {
		log.Printf("DeleteChannel: %v", err)
	} else {
		fmt.Printf("Deleted channel: %s\n", channelName)
	}

	// Typed convenience method — no channel-type constant needed.
	typedName := "go-management.delete-channel.typed"
	_ = client.CreateEventsChannel(ctx, typedName)
	err = client.DeleteEventsChannel(ctx, typedName)
	if err != nil {
		log.Printf("DeleteEventsChannel: %v", err)
	} else {
		fmt.Printf("Deleted events channel (typed): %s\n", typedName)
	}
}

```

## How It Works [#how-it-works]

1. `client.DeleteChannel(ctx, name, channelType)` removes the channel from the broker; any unprocessed messages in the channel are discarded.
2. The typed convenience method `client.DeleteEventsChannel(ctx, name)` wraps the generic form without requiring the `ChannelTypeEvents` constant.
3. The example first creates the channel to guarantee it exists before demonstrating the delete — useful in tests or CI pipelines that want a clean teardown.
4. Deleting a channel that does not exist returns an error; use `errors.As` with `*kubemq.KubeMQError` to inspect the code and skip `ErrCodeNotFound` in cleanup flows.

## Related [#related]

* [Go SDK Reference](/sdks/go/reference)
* [Create Channel](/sdks/go/how-to/management/create-channel)
* [List Channels](/sdks/go/how-to/management/list-channels)