Archiving Channels

Channel members can archive a channel for themselves. This is a per-user setting that does not affect other members.

Archived channels function identically to regular channels via the API, but your UI can display them separately. When a channel is archived, the timestamp is recorded and returned as archived_at in the response.

When querying channels, filter by archived: true to retrieve only archived channels, or archived: false to exclude them.

Archive a Channel

// Retrieve ChannelClient
val channelClient = client.channel("messaging", "example")

// Archive the channel
channelClient.archive().enqueue { /* ... */ }

// Query for channels that are archived
val query = QueryChannelsRequest(
  filter = Filters.eq("archived", true),
  offset = 0,
  limit = 10,
)
client.queryChannels(query).enqueue { /* ... */ }

// Unarchive the channel
channelClient.unarchive().enqueue { /* ... */ }

// Get a channel
const channel = client.channel("messaging", "example");

// Archive the channel
await channel.archive();

// Query for channels that are not archived
const resp = await client.queryChannels({ archived: false });

// Unarchive the channel
await channel.unarchive();

// Archive the channel
await channel.archive();

// Query for channels that are not archived
final channels = await client.queryChannelsOnline(filter: Filter.equal('archived', false));

// Unarchive the channel
await channel.unarchive();

ctx := context.Background()

// Get a channel
channel := client.Channel("messaging", "general")

// Archive the channel for user amy
userID := "amy"
channelMemberResp, err := channel.Archive(ctx, userID)

// Query for channels that are archived
resp, err := client.QueryChannels(ctx, &QueryOption{
	UserID: userID,
	Filter: map[string]interface{}{
		"archived": true,
	},
})

// Unarchive the channel
channelMemberResp, err = channel.Unarchive(ctx, userID)

// Get a channel
$channel = $client->channel("messaging", "general");

// Archive the channel for user amy
$userId = "amy";
$response = $channel->archive($userId);

// Query for channels that are archived
$response = $client->queryChannels([
    "archived" => true,
], null, [
    "user_id" => $userId
]);

// Unarchive the channel
$response = $channel->unarchive($userId);

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

# Archive the channel for user amy
user_id = "amy"
response = channel.archive(user_id)

# Query for channels that are archived
response = client.query_channels({"archived": True}, user_id=user_id)

# Unarchive the channel
response = channel.unarchive(user_id)

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

# Archive the channel for user amy
user_id = "amy"
response = channel.archive(user_id)

# Query for channels that are archived
response = client.query_channels({ 'archived': true }, sort: nil, user_id: user_id)

# Unarchive the channel
response = channel.unarchive(user_id)

// Archive the channel for user amy.
Channel.archive(channel.getType(), channel.getId(), "amy").request();

// Query for amy's channels that are archived.
Channel.list()
    .userId("amy")
    .filterCondition(FilterCondition.in("members", "amy"))
    .filterCondition("archived", true)
    .request();

// Unarchive
Channel.unarchive(channel.getType(), channel.getId(), "amy").request();

// Controllers

// Archive the channel for the current user.
channelController.archive { error in
    if let error {
        // handle error
    }
}

// Query all the archived channels.
let channelListController = chatClient.channelListController(
    query: ChannelListQuery(
        filter: .and([
            .containMembers(userIds: [currentUserId]),
            .equal(.archived, to: true)
        ])
    )
)
channelListController.synchronize { error in
    if let error {
        // handle error
    } else {
        let archivedChannels = channelListController.channels
    }
}

// Unarchive the channel for the current user.
channelController.unarchive { error in
    if let error {
        // handle error
    }
}

// State layer (async-await)

// Archive the channel for the current user.
try await chat.archive()

// Query all the archived channels.
let channelList = chatClient.makeChannelList(
    with: ChannelListQuery(
        filter: .and([
            .containMembers(userIds: [currentUserId]),
            .equal(.archived, to: true)
        ])
    )
)
try await channelList.get()
let archivedChannels = channelList.state.channels

// Unarchive the channel for the current user.
try await chat.unarchive()

// Archive
var archiveResponse = await _channelClient.ArchiveAsync("messaging", "channel-id", "user-id");

// Get the date when the channel got archived by the user
var archivedAt = archiveResponse.ChannelMember.ArchivedAt;

// Get channels that are NOT archived
var unarchivedChannels = await _channelClient.QueryChannelsAsync(new QueryChannelsOptions
{
    Filter = new Dictionary<string, object>
    {
        { "archived", false },
    },
    UserId = "user-id",
});

// Unarchive
var unarchiveResponse = await _channelClient.UnarchiveAsync("messaging", "channel-id", "user-id");

Global Archiving

To archive a channel for all users, use filter_tags to tag the channel as archived. This allows you to query for globally archived channels across your application.

// Archive globally by adding an "archived" tag
val channelClient = client.channel("messaging", "general")
channelClient.update(message = null, extraData = mapOf("filter_tags" to listOf("archived"))).enqueue { /* ... */ }

// Query globally archived channels
val filter = Filters.`in`("filter_tags", listOf("archived"))
val request = QueryChannelsRequest(filter = filter, limit = 30)
client.queryChannels(request).enqueue { /* ... */ }

// Archive globally by adding an "archived" tag
await channel.update({ filter_tags: ["archived"] });

// Query globally archived channels
const archived = await client.queryChannels({
  filter_tags: { $in: ["archived"] },
});

// Archive globally by adding an "archived" tag
Channel.update("messaging", "general")
    .filterTags(List.of("archived"))
    .request();

// Query globally archived channels
Channel.list()
    .filterCondition("filter_tags", FilterCondition.in("archived"))
    .request();

// Archive globally by adding an "archived" tag
try await channel.update(filterTags: ["archived"])

// Query globally archived channels
let channelListController = chatClient.channelListController(
    query: .init(filter: .in(.filterTags, values: ["archived"]))
)
channelListController.synchronize { error in
    if let error {
        // handle error
    }
}

// Archive globally by adding an "archived" tag
await channel.update({"filter_tags": ["archived"]});

// Query globally archived channels
final archived = await client.queryChannels(
  filter: Filter.in_("filter_tags", ["archived"]),
);

# Archive globally by adding an "archived" tag
channel.update({"filter_tags": ["archived"]})

# Query globally archived channels
archived = client.query_channels({"filter_tags": {"$in": ["archived"]}})

// Archive globally by adding an "archived" tag
channel.Update(ctx, map[string]interface{}{
    "filter_tags": []string{"archived"},
}, nil)

// Query globally archived channels
filter := map[string]interface{}{
    "filter_tags": map[string]interface{}{
        "$in": []string{"archived"},
    },
}
resp, err := client.QueryChannels(ctx, &QueryOption{Filter: filter})

// Archive globally by adding an "archived" tag
$channel->update(["filter_tags" => ["archived"]]);

// Query globally archived channels
$archived = $client->queryChannels(["filter_tags" => ["$in" => ["archived"]]]);

# Archive globally by adding an "archived" tag
channel.update({"filter_tags" => ["archived"]})

# Query globally archived channels
archived = client.query_channels({"filter_tags" => {"$in" => ["archived"]}})

// Archive globally by adding an "archived" tag
await channelClient.UpdateAsync("messaging", "general", new ChannelUpdateRequest
{
    FilterTags = new[] { "archived" }
});

// Query globally archived channels
var archived = await channelClient.QueryChannelsAsync(new QueryChannelsOptions
{
    Filter = new Dictionary<string, object>
    {
        { "filter_tags", new Dictionary<string, object> { { "$in", new[] { "archived" } } } }
    }
});

Channel Management

Pinning Channels