# Deleting Channels

You can delete or truncate a channel to remove its contents. To remove only messages while preserving the channel, see [Truncate Channel](/chat/docs/<framework>/truncate_channel/).

## Deleting a Channel

You can delete a single Channel using the  `delete`  method. This marks the channel as deleted and hides all the messages.

<codetabs>

<codetabs-item value="kotlin" label="Kotlin">

```kotlin
val channelClient = client.channel("messaging", "general")

channelClient.delete().enqueue { result ->
  if (result is Result.Success) {
    val channel = result.value
  } else {
    // Handle Result.Failure
  }
}
```

</codetabs-item>

<codetabs-item value="javascript" label="JavaScript">

```js
const destroy = await channel.delete();
```

</codetabs-item>

<codetabs-item value="php" label="PHP">

```php
use GetStream\ChatClient;
use GetStream\GeneratedModels as Models;

$client = new ChatClient("{{ api_key }}", "{{ api_secret }}");

$client->deleteChannel("messaging", "general", false);
```

</codetabs-item>

<codetabs-item value="dart" label="Dart">

```dart
await channel.delete();
```

</codetabs-item>

<codetabs-item value="swift" label="Swift">

```swift
import Stream Chat

let controller = chatClient.channelController(for: .init(type: .messaging, id: "general"))

controller.deleteChannel { error in
  if let error = error {
    // handle error
    print(error)
  }
}
```

</codetabs-item>

<codetabs-item value="unreal" label="Unreal">

```cpp
Channel->Delete();
```

</codetabs-item>

<codetabs-item value="ruby" label="Ruby">

```ruby
require 'getstream_ruby'

Models = GetStream::Generated::Models

client.chat.delete_channel("messaging", "general")
```

</codetabs-item>

<codetabs-item value="python" label="Python">

```python
# Get a channel
channel = client.chat.channel("messaging", "general")

channel.delete()
```

</codetabs-item>

<codetabs-item value="go" label="Go">

```go
channel := client.Chat().Channel("messaging", "general")

channel.Delete(ctx, &getstream.DeleteChannelRequest{})
```

</codetabs-item>

<codetabs-item value="csharp" label="C#">

```csharp
using GetStream;
using GetStream.Models;

var client = new StreamClient("{{ api_key }}", "{{ api_secret }}");
var chat = new ChatClient(client);

var channelId = "channel-id";

// Soft delete
await chat.DeleteChannelAsync("messaging", channelId);

// Hard delete
await chat.DeleteChannelAsync("messaging", channelId,
    new { hard_delete = "true" });
```

</codetabs-item>

<codetabs-item value="unity" label="Unity">

```csharp
// Soft delete channel
await channel.DeleteAsync();
```

</codetabs-item>

<codetabs-item value="java" label="Java">

```java
// Backend SDK
chat.deleteChannel(channel.getType(), channel.getId(),
    DeleteChannelRequest.builder().build()).execute();

// Hard delete
chat.deleteChannel(channel.getType(), channel.getId(),
    DeleteChannelRequest.builder().HardDelete(true).build()).execute();
```

</codetabs-item>

</codetabs>

<admonition type="info">

If you recreate this channel, it will show up empty. Recovering old messages is not supported. Use the disable method if you want a reversible change.

</admonition>

## Deleting Many Channels

You can delete up to 100 channels and optionally all of their messages using this method. This can be a large amount of data to delete, so this endpoint processes asynchronously, meaning responses contain a `task ID` which can be polled using the [getTask endpoint](/chat/docs/<framework>#tasks-gettask) to check status of the deletions. Channels will be soft-deleted immediately so that channels no longer return from queries, but permanently deleting the channel and deleting messages takes longer to process.

By default, messages are soft deleted, which means they are removed from client but are still available via server-side export functions. You can also hard delete messages, which deletes them from everywhere, by setting `"hard_delete": true` in the request. Messages that have been soft or hard deleted cannot be recovered.

This is currently supported on the following SDK versions (or higher):

- Javascript 4.3.0, Python 3.14.0, Ruby 2.12.0, PHP 2.6.0, Go 3.13.0, Java 1.4.0, Unity 2.0.0 and .NET 0.22.0

<codetabs>

<codetabs-item value="javascript" label="JavaScript">

```js
// client-side soft delete
const response = await client.deleteChannels([cid1, cid2]);
// client-side hard delete
const response = await client.deleteChannels([cid1, cid2], {
  hard_delete: true,
});
const result = response.result; // holds deletion result

// server-side soft delete
const response = await serverClient.deleteChannels([cid1, cid2]);
// server-side hard delete
const response = await serverClient.deleteChannels([cid1, cid2], {
  hard_delete: true,
});

const result = await serverClient.getTask(response.task_id);
if (result["status"] === "completed") {
  // success!
}
```

</codetabs-item>

<codetabs-item value="go" label="Go">

```go
// soft deletion
resp, _ := client.Chat().DeleteChannels(ctx, &getstream.DeleteChannelsRequest{
	Cids: []string{cid1, cid2},
})

// hard deletion
resp, _ = client.Chat().DeleteChannels(ctx, &getstream.DeleteChannelsRequest{
	Cids:       []string{cid1, cid2},
	HardDelete: getstream.PtrTo(true),
})

taskResp, err := client.GetTask(ctx, *resp.Data.TaskID, &getstream.GetTaskRequest{})
if err != nil {
	// handle error
}
if taskResp.Data.Status == "completed" {
	// success!
}
```

</codetabs-item>

<codetabs-item value="python" label="Python">

```python
# soft deletion
response = client.chat.delete_channels(cids=[cid1, cid2])
# hard deletion
response = client.chat.delete_channels(cids=[cid1, cid2], hard_delete=True)

task_response = client.get_task(id=response.data.task_id)
if task_response.data.status == "completed":
    # success!
    pass
```

</codetabs-item>

<codetabs-item value="ruby" label="Ruby">

```ruby
require 'getstream_ruby'

Models = GetStream::Generated::Models

# soft deletion
response = client.chat.delete_channels(Models::DeleteChannelsRequest.new(
  cids: [cid1, cid2]
))

# hard deletion
response = client.chat.delete_channels(Models::DeleteChannelsRequest.new(
  cids: [cid1, cid2],
  hard_delete: true
))

task_response = client.common.get_task(response.task_id)
if task_response.status == 'completed'
  # success!
end
```

</codetabs-item>

<codetabs-item value="php" label="PHP">

```php
// soft deletion
$response = $client->deleteChannels(new Models\DeleteChannelsRequest(
    cids: ["messaging:channel-1", "messaging:channel-2"],
));

// hard deletion
$response = $client->deleteChannels(new Models\DeleteChannelsRequest(
    cids: ["messaging:channel-1", "messaging:channel-2"],
    hardDelete: true,
));

$taskResponse = $client->getTask($response->getData()->taskID);
```

</codetabs-item>

<codetabs-item value="java" label="Java">

```java
// soft deletion
var response = chat.deleteChannels(DeleteChannelsRequest.builder()
    .cids(List.of(cid1, cid2))
    .build()).execute();

// hard deletion
var response = chat.deleteChannels(DeleteChannelsRequest.builder()
    .cids(List.of(cid1, cid2))
    .hardDelete(true)
    .build()).execute();

var taskResponse = client.getTask(response.getData().getTaskId()).execute();
// "completed".equals(taskResponse.getData().getStatus());
```

</codetabs-item>

<codetabs-item value="csharp" label="C#">

```csharp
using GetStream;
using GetStream.Models;

var client = new StreamClient("{{ api_key }}", "{{ api_secret }}");
var chat = new ChatClient(client);

// Soft deletion
var resp = await chat.DeleteChannelsAsync(new DeleteChannelsRequest
{
    Cids = new List<string> { "messaging:channel-1", "messaging:channel-2" },
    HardDelete = false
});

// Hard deletion
resp = await chat.DeleteChannelsAsync(new DeleteChannelsRequest
{
    Cids = new List<string> { "messaging:channel-1", "messaging:channel-2" },
    HardDelete = true
});
```

</codetabs-item>

<codetabs-item value="unity" label="Unity">

```csharp
// Hard delete removes the channel entirely from the database while soft delete removes the from users to see but it's still accessible via server-side SDK as an archive
await Client.DeleteMultipleChannelsAsync(new[] { channel, channel2 }, isHardDelete: true);
```

</codetabs-item>

</codetabs>

The  `deleteChannels`  response contain a taskID which can be polled using the [getTask endpoint](/chat/docs/<framework>#tasks-gettask) to check the status of the deletions.


---

This page was last updated at 2026-03-13T13:17:14.692Z.

For the most recent version of this documentation, visit [https://getstream.io/chat/docs/unity/channel_delete/](https://getstream.io/chat/docs/unity/channel_delete/).