# Freezing Channels

Freezing a channel prevents users from sending new messages and adding or deleting reactions.

Sending a message to a frozen channel returns an error message. Attempting to add or delete reactions returns a `403 Not Allowed` error.

User roles with the `UseFrozenChannel` permission can still use frozen channels normally. By default, no user role has this permission.

## Freeze a Channel

<Tabs>

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

channelClient.updatePartial(set = mapOf("frozen" to true)).enqueue { result ->
  if (result is Result.Success) {
    val channel = result.value
  } else {
    // Handle Result.Failure
  }
}
```

```js label="JavaScript"
const update = await channel.update(
	{ frozen: true },
	{ text: 'Thierry has frozen the channel', user_id: "Thierry" }
)

const update = await channel.updatePartial(
	{set: {frozen: true}
)
```

```swift label="Swift"
let channelController = client.channelController(for: .init(type: .messaging, id: "general"))

// Controllers

channelController.freezeChannel()

// State layer (async-await)

try await chat.freeze()
```

```php label="PHP"
use GetStream\ChatClient;
use GetStream\GeneratedModels as Models;

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

$client->updateChannelPartial("messaging", "general", new Models\UpdateChannelPartialRequest(
    set: (object)["frozen" => true],
));
```

```python label="Python"
from getstream.models import ChannelInputRequest

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

channel.update(data=ChannelInputRequest(frozen=True))
```

```ruby label="Ruby"
require 'getstream_ruby'

Models = GetStream::Generated::Models

client.chat.update_channel_partial("messaging", "general", Models::UpdateChannelPartialRequest.new(
  set: { 'frozen' => true }
))
```

```java label="Java"
// Android SDK
ChannelClient channelClient = client.channel("messaging", "general");
Map<String, Object> set = new HashMap<>();
set.put("frozen", true);
List<String> unset = new ArrayList<>();

channelClient.updatePartial(set, unset).enqueue(result -> {
  if (result.isSuccess()) {
    Channel channel = result.getOrThrow();
  } else {
    // Handle Result.Failure
  }
});

// Backend SDK
chat.updateChannelPartial(channel.getType(), channel.getId(),
    UpdateChannelPartialRequest.builder()
        .set(Map.of("frozen", true))
        .build()).execute();
```

```csharp label="C#"
using GetStream;
using GetStream.Models;

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

var channelId = "channel-id";

// Freeze a channel
await chat.UpdateChannelPartialAsync("messaging", channelId,
    new UpdateChannelPartialRequest
    {
        Set = new Dictionary<string, object> { ["frozen"] = true }
    });
```

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

channel.UpdateChannelPartial(ctx, &getstream.UpdateChannelPartialRequest{
	Set: map[string]any{"frozen": true},
})
```

```csharp label="Unity"
await channel.FreezeAsync();
```

</Tabs>

## Unfreeze a Channel

<Tabs>

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

channelClient.updatePartial(set = mapOf("frozen" to false)).enqueue { result ->
  if (result is Result.Success) {
    val channel = result.value
  } else {
    // Handle Result.Failure
  }
}
```

```js label="JavaScript"
const update = await channel.update(
  { frozen: false },
  { text: "Thierry has unfrozen the channel", user_id: "Thierry" },
);
```

```swift label="Swift"
let channelController = client.channelController(for: .init(type: .messaging, id: "general"))

// Controllers

channelController.unfreezeChannel()

// State layer (async-await)

try await chat.unfreeze()
```

```php label="PHP"
$client->updateChannelPartial("messaging", "general", new Models\UpdateChannelPartialRequest(
    set: (object)["frozen" => false],
));
```

```python label="Python"
from getstream.models import ChannelInputRequest

channel.update(data=ChannelInputRequest(frozen=False))
```

```ruby label="Ruby"
require 'getstream_ruby'

Models = GetStream::Generated::Models

client.chat.update_channel_partial("messaging", "general", Models::UpdateChannelPartialRequest.new(
  set: { 'frozen' => false }
))
```

```java label="Java"
// Android SDK
ChannelClient channelClient = client.channel("messaging", "general");
Map<String, Object> set = new HashMap<>();
set.put("frozen", false);
List<String> unset = new ArrayList<>();

channelClient.updatePartial(set, unset).enqueue(result -> {
  if (result.isSuccess()) {
    Channel channel = result.getOrThrow();
  } else {
    // Handle Result.Failure
  }
});

// Backend SDK
chat.updateChannelPartial(channel.getType(), channel.getId(),
    UpdateChannelPartialRequest.builder()
        .set(Map.of("frozen", false))
        .build()).execute();
```

```csharp label="C#"
using GetStream;
using GetStream.Models;

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

var channelId = "channel-id";

// Unfreeze a channel
await chat.UpdateChannelPartialAsync("messaging", channelId,
    new UpdateChannelPartialRequest
    {
        Set = new Dictionary<string, object> { ["frozen"] = false }
    });
```

```go label="Go"
channel.UpdateChannelPartial(ctx, &getstream.UpdateChannelPartialRequest{
	Set: map[string]any{"frozen": false},
})
```

```csharp label="Unity"
await channel.UnfreezeAsync();
```

</Tabs>

## Granting the Frozen Channel Permission

Permissions are typically managed in the [Stream Dashboard](https://dashboard.getstream.io/) under your app's **Roles & Permissions** settings. This is the recommended approach for most use cases.

To grant permissions programmatically, update the channel type using a server-side API call. See [user permissions](/chat/docs/unity/chat-permission-policies/) for more details.

<Tabs>

```js label="JavaScript"
const { grants } = await client.getChannelType("messaging");
grants.admin.push("use-frozen-channel");
await client.updateChannelType("messaging", {
  grants: { admin: grants.admin },
});
```

```php label="PHP"
$response = $client->getChannelType("messaging");
$grants = $response->getData()->grants;
$grants["admin"][] = "use-frozen-channel";

$client->updateChannelType("messaging", new Models\UpdateChannelTypeRequest(
    grants: ["admin" => $grants["admin"]],
));
```

```python label="Python"
resp = client.chat.get_channel_type("messaging")

admin_grants = resp.data.grants["admin"] + ["use-frozen-channel"]

client.chat.update_channel_type(
    "messaging",
    automod=resp.data.automod,
    automod_behavior=resp.data.automod_behavior,
    max_message_length=resp.data.max_message_length,
    grants={"admin": admin_grants},
)
```

```ruby label="Ruby"
require 'getstream_ruby'

Models = GetStream::Generated::Models

resp = client.chat.get_channel_type("messaging")

admin_grants = resp.grants['admin'] + ['use-frozen-channel']

client.chat.update_channel_type("messaging", Models::UpdateChannelTypeRequest.new(
  automod: resp.automod,
  automod_behavior: resp.automod_behavior,
  max_message_length: resp.max_message_length,
  grants: { 'admin' => admin_grants }
))
```

```go label="Go"
resp, err := client.Chat().GetChannelType(ctx, "messaging", &getstream.GetChannelTypeRequest{})
adminGrants := append(resp.Data.Grants["admin"], "use-frozen-channel")

client.Chat().UpdateChannelType(ctx, "messaging", &getstream.UpdateChannelTypeRequest{
	Automod:          resp.Data.Automod,
	AutomodBehavior:  resp.Data.AutomodBehavior,
	MaxMessageLength: resp.Data.MaxMessageLength,
	Grants:           map[string][]string{"admin": adminGrants},
})
```

```java label="Java"
// Backend SDK
var resp = chat.getChannelType("messaging").execute().getData();
var currentGrants = resp.getGrants();

List<String> adminGrants = new ArrayList<>(currentGrants.get("admin"));
adminGrants.add("use-frozen-channel");
currentGrants.put("admin", adminGrants);

chat.updateChannelType("messaging", UpdateChannelTypeRequest.builder()
    .grants(currentGrants)
    .automod(resp.getAutomod())
    .automodBehavior(resp.getAutomodBehavior())
    .maxMessageLength(resp.getMaxMessageLength())
    .build()).execute();
```

```csharp label="Unity"
// For security reasons, granting channel permissions is only possible via a server-side SDK
```

</Tabs>


---

This page was last updated at 2026-05-22T16:32:21.403Z.

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