Muting Channels

Muting a channel prevents it from triggering push notifications, unhiding, or incrementing the unread count for that user.

By default, mutes remain active indefinitely until removed. You can optionally set an expiration time. The list of muted channels and their expiration times is returned when the user connects.

Mute a Channel

// Mute a channel
val channelClient = client.channel("messaging", "general")
channelClient.mute().enqueue { result ->
  if (result is Result.Success) {
    // Channel is muted
  } else {
    // Handle Result.Failure
  }
}

// Get list of muted channels when user is connected
client.connectUser(User("user-id"), "token")
  .enqueue { result ->
    if (result is Result.Success) {
      val user = result.value.user
      // Result contains the list of channel mutes
      val mutes: List<ChannelMute> = user.channelMutes
    }
  }

// Get updates about muted channels
client.subscribeFor<NotificationChannelMutesUpdatedEvent> { event ->
  val mutes: List<ChannelMute> = event.me.channelMutes
}

const reply = await client.connectUser(user, token);

// reply.me.channel_mutes contains the list of channel mutes
console.log(reply.me.channel_mutes);

const channel = client.channel("messaging", "channel-id");

// mute channel for current user
await channel.mute();

// mute channel for a user (server-side)
await channel.mute({ user_id: userId });

// mute a channel for 2 weeks
await channel.mute({ expiration: moment.duration(2, "weeks") });

// mute a channel for 10 seconds
await channel.mute({ expiration: 10000 });

// check if channel is muted
// { muted: true | false, createdAt: Date | null, expiresAt: Date | null}
channel.muteStatus();

import StreamChat

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

// Controllers

// mute channel
controller.muteChannel { error in
  if let error = error {
    // handle error
    print(error)
  }
}

// mute channel for 2 weeks (expiration in milliseconds)
controller.muteChannel(expiration: 14 * 24 * 60 * 60 * 1000) { error in
  if let error = error {
    // handle error
    print(error)
  }
}

// State layer (async-await)

// mute channel
try await chat.mute()

// mute channel for 2 weeks (expiration in milliseconds)
try await chat.mute(expiration: 14 * 24 * 60 * 60 * 1000)

// mute channel for current user
await channel.mute();

// mute a channel for 2 weeks
await channel.mute(expiration: Duration(days: 15));

// mute a channel for 10 seconds
await channel.mute(expiration: Duration(seconds: 10));

// check if channel is muted
channel.isMuted;

// mute channel for current user
Channel->Mute();

// mute a channel for 2 weeks
Channel->Mute({FTimespan::FromDays(15.)});

// mute a channel for 10 seconds
Channel->Mute({FTimespan::FromSeconds(10.)});

// check if channel is muted
Channel->IsMuted();

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

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

$client->muteChannel(new Models\MuteChannelRequest(
    channelCids: ["messaging:general"],
    userID: "john",
));

// With expiration (in milliseconds)
$client->muteChannel(new Models\MuteChannelRequest(
    channelCids: ["messaging:general"],
    userID: "john",
    expiration: 1000,
));

client.chat.mute_channel(channel_cids=["messaging:general"], user_id="john")

# With expiration (in milliseconds)
client.chat.mute_channel(channel_cids=["messaging:general"], user_id="john", expiration=30000)

require 'getstream_ruby'

Models = GetStream::Generated::Models

client.chat.mute_channel(Models::MuteChannelRequest.new(
  channel_cids: ['messaging:general'],
  user_id: 'john'
))

# With expiration (in milliseconds)
client.chat.mute_channel(Models::MuteChannelRequest.new(
  channel_cids: ['messaging:general'],
  user_id: 'john',
  expiration: 1000
))

using GetStream;
using GetStream.Models;

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

// Mute
await chat.MuteChannelAsync(new MuteChannelRequest
{
    ChannelCids = new List<string> { "messaging:channel-id" },
    UserID = "john"
});

// With expiration (in milliseconds)
await chat.MuteChannelAsync(new MuteChannelRequest
{
    ChannelCids = new List<string> { "messaging:channel-id" },
    UserID = "john",
    Expiration = 1000
});

client.Chat().MuteChannel(ctx, &getstream.MuteChannelRequest{
	ChannelCids: []string{"messaging:general"},
	UserID:      getstream.PtrTo("john"),
})

// With expiration (in milliseconds)
client.Chat().MuteChannel(ctx, &getstream.MuteChannelRequest{
	ChannelCids: []string{"messaging:general"},
	UserID:      getstream.PtrTo("john"),
	Expiration:  getstream.PtrTo(21600000),
})

// Android SDK

// Mute a channel
ChannelClient channelClient = client.channel("messaging", "general");
channelClient.mute().enqueue(result -> {
  if (result.isSuccess()) {
    // Channel is muted
  } else {
    // Handle result.error()
  }
});

// Get list of muted channels when user is connected
User user = new User();
user.setId("user-id");
client.connectUser(user, "token").enqueue(result -> {
  if (result.isSuccess()) {
    // Result contains the list of channel mutes
    List<ChannelMute> mutes = result.data().getUser().getChannelMutes();
  }
 });

// Get updates about muted channels
client.subscribeFor(
    new Class[]{NotificationChannelMutesUpdatedEvent.class},
    channelsMuteEvent -> {
      List<ChannelMute> mutes = ((NotificationChannelMutesUpdatedEvent) channelsMuteEvent).getMe().getChannelMutes();
    }
);

// Backend SDK
chat.muteChannel(MuteChannelRequest.builder()
    .channelCids(List.of(channel.getType() + ":" + channel.getId()))
    .userID(user.getId())
    .expiration(1209600000) // Optionally set mute duration (in milliseconds, e.g. 14 days)
    .build()).execute();

Messages added to muted channels do not increase the unread messages count.

Query Muted Channels

Muted channels can be filtered or excluded by using the muted in your query channels filter.

// Filter for all channels excluding muted ones
val notMutedFilter = Filters.and(
  Filters.eq("muted", false),
  Filters.`in`("members", listOf(currentUserId)),
)

// Filter for muted channels
val mutedFilter = Filters.eq("muted", true)

// Executing a channels query with either of the filters
client.queryChannels(QueryChannelsRequest(
  filter = filter, // Set the correct filter here
  offset = 0,
  limit = 10,
)).enqueue { result ->
  if (result is Result.Success) {
    val channels: List<Channel> = result.value
  } else {
    // Handle Result.Failure
  }
}

// retrieve all channels excluding muted ones
await client.queryChannels({ members: { $in: [userId] }, muted: false });

// retrieve all muted channels
await client.queryChannels({ muted: true });

// Controllers

let controller = chatClient.channelListController(
  query: .init(
    filter: .equal(.muted, to: true)
  )
)
controller.synchronize { error in
  print(error ?? controller.channels)
}

// State layer (async-await)

let channelList = chatClient.makeChannelList(
  with: ChannelListQuery(
    filter: .equal(.muted, to: true)
  )
)
try await channelList.get()
let mutedChannels = channelList.state.channels

// retrieve all channels excluding muted ones
await client.queryChannels(
  filter: {
   'members': {
    r'$in': [userId],
   },
   'muted': false,
  }
 );

// retrieve all muted channels
await client.queryChannels(
  filter: {
   'muted': true,
  }
 );

// retrieve all channels excluding muted ones
const FFilter NotMuted = FFilter::And({
  FFilter::In(TEXT("members"), {UserId}),
  FFilter::Equal(TEXT("muted"), false),
});
Client->QueryChannels(NotMuted);

// retrieve all muted channels
const FFilter Muted = FFilter::Equal(TEXT("muted"), true);
Client->QueryChannels(Muted);

$response = $client->queryChannels(new Models\QueryChannelsRequest(
    filterConditions: (object)["muted" => true],
    userID: "john",
));

require 'getstream_ruby'

Models = GetStream::Generated::Models

client.chat.query_channels(Models::QueryChannelsRequest.new(
  filter_conditions: { 'muted' => true }
))

using GetStream;
using GetStream.Models;

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

// Query muted channels is not directly available; use the mute/unmute methods above.
// Muted channel state is returned when the user connects.

// Android SDK

// Filter for all channels excluding muted ones
FilterObject notMutedFilter = Filters.and(
    Filters.eq("muted", false),
    Filters.in("members", Arrays.asList(currentUserId))
);

// Filter for muted channels
FilterObject mutedFilter = Filters.eq("muted", true);

// Executing a channels query with either of the filters
int offset = 0;
int limit = 10;
QuerySorter<Channel> sort = new QuerySortByField<>();
int messageLimit = 0;
int memberLimit = 0;
client.queryChannels(new QueryChannelsRequest(
    filter, // Set the correct filter here
    offset,
    limit,
    sort,
    messageLimit,
    memberLimit)).enqueue(result -> {
  if (result.isSuccess()) {
    List<Channel> channels = result.data();
  } else {
    // Handle result.error()
  }
});

// Backend SDK

// retrieve all channels excluding muted ones
chat.queryChannels(QueryChannelsRequest.builder()
    .filterConditions(Map.of(
        "muted", false,
        "members", Map.of("$in", List.of(userId))))
    .build()).execute();

Remove a Channel Mute

Use the unmute method to restore normal notifications and unread behavior for a channel.

// Unmute channel for current user
channelClient.unmute().enqueue { result ->
  if (result is Result.Success) {
    // Channel is unmuted
  } else {
    // Handle Result.Failure
  }
}

// unmute channel for current user
await channel.unmute();

// unmute channel for a user (server-side)
await channel.unmute({ user_id: userId });

import StreamChat

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

// Controllers

// unmute channel
controller.unmuteChannel { error in
  if let error = error {
    // handle error
    print(error)
  }
}

// State layer (async-await)

// unmute channel
try await chat.unmute()

// unmute channel for current user
await channel.unmute();

// unmute channel for a user (server-side)
await channel.unmute({ user_id: userId });

require 'getstream_ruby'

Models = GetStream::Generated::Models

client.chat.unmute_channel(Models::UnmuteChannelRequest.new(
  channel_cids: ['messaging:general'],
  user_id: 'john'
))

using GetStream;
using GetStream.Models;

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

// Unmute
await chat.UnmuteChannelAsync(new UnmuteChannelRequest
{
    ChannelCids = new List<string> { "messaging:channel-id" },
    UserID = "john"
});

client.Chat().UnmuteChannel(ctx, &getstream.UnmuteChannelRequest{
	ChannelCids: []string{"messaging:general"},
	UserID:      getstream.PtrTo("john"),
})

// Android SDK

// Unmute channel for current user
channelClient.unmute().enqueue(result -> {
  if (result.isSuccess()) {
    // Channel is unmuted
  } else {
    // Handle result.error()
  }
});

// Backend SDK
chat.unmuteChannel(UnmuteChannelRequest.builder()
    .channelCids(List.of(cid))
    .userID(userId)
    .build()).execute();

Pinning Channels

Hiding Channels

On this page:

Mute a Channel
- Query Muted Channels
- Remove a Channel Mute