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

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
  }
}

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

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

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

// Controllers

channelController.freezeChannel()

// State layer (async-await)

try await chat.freeze()

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],
));

from getstream.models import ChannelInputRequest

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

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

require 'getstream_ruby'

Models = GetStream::Generated::Models

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

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

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

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

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 }
    });

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

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

await channel.FreezeAsync();

Unfreeze a Channel

Granting the Frozen Channel Permission

Permissions are typically managed in the Stream Dashboard 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 for more details.

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

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

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

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},
)

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 }
))

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},
})

// 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();

// For security reasons, granting channel permissions is only possible via a server-side SDK

Deleting Channels

Truncate Channel