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

channelController.freezeChannel()

$channel->update(["frozen" => true]);

channel.update({"frozen": True})

channel.update({"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
ChannelRequestObject channelRequestObject = ChannelRequestObject.buildFrom(channel);
channelRequestObject.setFrozen(true);
Channel.update(channel.getType(), channel.getId())
  .data(channelRequestObject)
  .message(
    MessageRequestObject.builder()
      .text("Thierry has frozen the channel")
      .userId("Thierry")
      .build())
  .request();

var updateReq = new ChannelUpdateRequest { Data = new ChannelRequest { Frozen = true} };
await channelClient.UpdateAsync("<channel-type>", "<channel-id>", updateReq);

channel.Update(ctx, map[string]interface{}{"frozen": true}, nil)

await channel.FreezeAsync();

Unfreeze a Channel

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

channelClient.updatePartial(unset = listOf("frozen")).enqueue { result ->
  if (result is Result.Success) {
    val channel = result.value
  } else {
    // Handle Result.Failure
  }
}

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

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

channelController.unfreezeChannel()

$channel->update(["frozen" => false]);

channel.update({"frozen": False})

channel.update({"frozen" => false})

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

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

// Backend SDK
ChannelRequestObject channelRequestObject = ChannelRequestObject.buildFrom(channel);
channelRequestObject.setFrozen(false);
Channel.update(channel.getType(), channel.getId())
  .data(channelRequestObject)
  .message(
    MessageRequestObject.builder()
      .text("Thierry has unfrozen the channel")
      .userId("Thierry")
      .build())
  .request();

var updateReq = new ChannelUpdateRequest { Data = new ChannelRequest { Frozen = false} };
await channelClient.UpdateAsync("<channel-type>", "<channel-id>", updateReq);

channel.Update(ctx, map[string]interface{}{"frozen": false}, nil)

await channel.UnfreezeAsync();

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

$response["grants"]["admin"][] = "use-frozen-channel";

$client->updateChannelType("messaging", [ "grants" => ["admin" => $response["grants"]["admin"] ] ]);

resp = client.get_channel_type("messaging")

adminGrants = resp["grants"]["admin"] + ["use-frozen-channel"]

client.update_channel_type("messaging", grants={"admin": adminGrants})

resp = client.get_channel_type("messaging")

adminGrants = resp["grants"]["admin"] + ["use-frozen-channel"]

client.update_channel_type("messaging", grants: {"admin": adminGrants})

resp, err := c.GetChannelType(ctx, "messaging")
adminGrants = append(resp.Grants["admin"], "use-frozen-channel")

c.UpdateChannelType(ctx, "messaging", map[string]interface{}{"grants": map[string][]string{"admin": adminGrants}})

// Backend SDK
ChannelTypeGetResponse resp = ChannelType.get("messaging").request();
Map<String, List<String>> currentGrants = resp.getGrants();

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

ChannelType.update("messaging")
 .grants(currentGrants)
 .request();

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

Deleting Channels

Truncate Channel