Invites

Invites allow you to add users to a channel with a pending state. The invited user receives a notification and can accept or reject the invite.

Unread counts are not incremented for channels with a pending invite.

Invite Users

val channelClient = client.channel("messaging", "general")  channelClient.inviteMembers(memberIds = listOf("nick")).enqueue { result ->  if (result is Result.Success) {  val channel: Channel = result.value  } else {  // Handle Result.Failure  } }

await channel.inviteMembers(["nick"]);

$channel->inviteMembers(['thierry']);

final invite = client.channel("messaging", id: "awesome-chat",  extraData: {  "name": "Founder Chat",  "members": ["thierry", "tommaso"],  "invites": ["nick"],  });  await invite.create();

let controller = client.channelController(for: .init(type: .messaging, id: "general"))  controller.inviteMembers(userIds: ["thierry"])

// Not yet supported in the Unreal SDK

channel.invite_members(["thierry"])

# require 'stream-chat'  channel.invite_members(['thierry'])

channel.InviteMembers(ctx, "thierry")

await channelClient.InviteAsync("<channel-type>", "<channel-id>", "thierry");

// Android SDK ChannelClient channelClient = client.channel("messaging", "general");  List<String> memberIds = Arrays.asList("thierry", "tommaso"); Map<String, Object> data = new HashMap<>(); data.put("invites", Arrays.asList("nick"));  channelClient.create(memberIds, data).enqueue(result -> {  if (result.isSuccess()) {  Channel channel = result.data();  } else {  // Handle result.error()  }  });   // Backend SDK Channel.update("messaging", "general")  .invites(Arrays.asList("thierry", "tommaso"))  .request();

// Invite IStreamUser collection as new members await channel.InviteMembersAsync(users);  // Or add by ID await channel.InviteMembersAsync("some-user-id-1", "some-user-id-2");

Accept an Invite

Call acceptInvite to accept a pending invite. You can optionally include a message parameter to post a system message when the user joins (e.g., “Nick joined this channel!”).

channelClient.acceptInvite(  message = "Nick joined this channel!" ).enqueue { result ->  if (result is Result.Success) {  val channel: Channel = result.value  } else {  // Handle Result.Failure  } }

// initialize the channel const channel = client.channel("messaging", "awesome-chat");  // accept the invite await channel.acceptInvite({  message: { text: "Nick joined this channel!" }, });  // accept the invite server side await channel.acceptInvite({ user_id: "nick" });

// initialize the channel $channel = $client->Channel('messaging', 'team-chat-5');  // accept the invite $accept = $channel->acceptInvite(['user_id'=>'elon']);

final channel = client.channel("messaging", id: "awesome-chat"); await channel.acceptInvite();

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

// Not yet supported in the Unreal SDK

await channelClient.AcceptInviteAsync("<channel-type>", "<channel-id>", "thierry");

channel.accept_invite("thierry")

channel.accept_invite("thierry")

channel.AcceptInvite(ctx, "thierry", nil)

// Android SDK channelClient.acceptInvite("Nick joined this channel!").enqueue(result -> {  if (result.isSuccess()) {  Channel channel = result.data();  } else {  // Handle result.error()  } });  // Backend SDK Channel.update("messaging", "general")  .acceptInvite(true)  .userId("nick")  .message(MessageRequestObject.builder().text("Nick joined the channel").build())  .request();

await channel.AcceptInviteAsync();

Reject an Invite

Call rejectInvite to decline a pending invite. Client-side calls use the currently connected user. Server-side calls require a user_id parameter.

channelClient.rejectInvite().enqueue { result ->  if (result is Result.Success) {  // Invite rejected  } else {  // Handle Result.Failure  } }

await channel.rejectInvite();  //server side await channel.rejectInvite({ user_id: "rob" });

$reject = $channel->rejectInvite(['user_id'=>'elon']);

await channel.rejectInvite();

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

// Not yet supported in the Unreal SDK

await channelClient.RejectInviteAsync("<channel-type>", "<channel-id>", "thierry");

channel.reject_invite("thierry")

channel.reject_invite("thierry")

channel.RejectInvite(ctx, "thierry", nil)

// Android SDK channelClient.rejectInvite().enqueue(result -> {  if (result.isSuccess()) {  // Invite rejected  } else {  // Handle result.error()  } });  // Backend SDK Channel.update("messaging", "general")  .acceptInvite(false)  .userId("nick")  .request();

await channel.RejectInviteAsync();

Query Invites by Status

Use queryChannels with the invite filter to retrieve channels based on invite status. Valid values are pending, accepted, and rejected.

Query Accepted Invites

val request = QueryChannelsRequest(  filter = Filters.eq("invite", "accepted"),  offset = 0,  limit = 10 ) client.queryChannels(request).enqueue { result ->  if (result is Result.Success) {  val channels: List<Channel> = result.value  } else {  // Handle Result.Failure  } }

const invites = await client.queryChannels({  invite: "accepted", });  //server side (query invites for user rob) const invites = await client.queryChannels(  {  invite: "accepted",  },  {},  { user_id: "rob" }, );

$invites = $client->queryChannels(['invite' => 'accepted'],[], ['user_id' => 'jenny']);

final invites = await client.queryChannels(filter: {"invite": "accepted"});

import StreamChat  let controller = chatClient.channelListController(  query: .init(  filter: .equal(.invite, to: .accepted)  ) )  controller.synchronize { error in  if let error = error {  // handle error  print(error)  } else {  // access channels  print(controller.channels)   // load more if needed  controller.loadNextChannels(limit: 10) { _ in  // handle error / access channels  }  } }

Client->QueryChannels(FFilter::Equal(TEXT("invite"), TEXT("accepted")));

await channelClient.QueryChannelsAsync(QueryChannelsOptions.Default.WithFilter(new Dictionary<string, object> {  { "invite", "accepted" }, }));

client.query_channels({"invite": "accepted"})

client.query_channels({ 'invite' => 'accepted' })

client.QueryChannels(ctx, &QueryOption{ Filter: map[string]interface{}{ "invite": "accepted", }, })

// Android SDK FilterObject filter = Filters.eq("invite", "accepted"); int offset = 0; int limit = 10; QuerySorter<Channel> sort = new QuerySortByField<>(); int messageLimit = 0; int memberLimit = 0; QueryChannelsRequest request = new QueryChannelsRequest(filter, offset, limit, sort, messageLimit, memberLimit);  client.queryChannels(request).enqueue(result -> {  if (result.isSuccess()) {  List<Channel> channels = result.data();  } else {  // Handle result.error()  } });  // Backend SDK Channel.queryMembers().type("messaging").id("general").filterCondition("invite", "accepted").request();

var filter = new List<IFieldFilterRule> {  ChannelFilter.Invite.EqualsTo(ChannelFieldInvite.Status.Accepted) };  var sort = ChannelSort.OrderByDescending(ChannelSortFieldName.LastMessageAt);  var acceptedInvites = await Client.QueryChannelsAsync(filter, sort);

Query Rejected Invites

val request = QueryChannelsRequest(  filter = Filters.eq("invite", "rejected"),  offset = 0,  limit = 10 ) client.queryChannels(request).enqueue { result ->  if (result is Result.Success) {  val channels: List<Channel> = result.value  } else {  // Handle Result.Failure  } }

const rejected = client.queryChannels({  invite: "rejected", });  //server side (query invites for user rob) const invites = await client.queryChannels(  {  invite: "rejected",  },  {},  { user_id: "rob" }, );

$invites = $client->queryChannels(['invite' => 'rejected'],[], ['user_id' => 'jenny']);

final rejected = await client.queryChannels(filter: {"invite": "rejected"});

import StreamChat  let controller = chatClient.channelListController(  query: .init(  filter: .equal(.invite, to: .rejected)  ) )  controller.synchronize { error in  if let error = error {  // handle error  print(error)  } else {  // access channels  print(controller.channels)   // load more if needed  controller.loadNextChannels(limit: 10) { _ in  // handle error / access channels  }  } }

Client->QueryChannels(FFilter::Equal(TEXT("invite"), TEXT("rejected")));

await channelClient.QueryChannelsAsync(QueryChannelsOptions.Default.WithFilter(new Dictionary<string, object> {  { "invite", "rejected" }, }));

client.query_channels({"invite": "rejected"})

client.query_channels({ 'invite' => 'rejected' })

client.QueryChannels(ctx, &QueryOption{ Filter: map[string]interface{}{ "invite": "rejected", }, })

// Android SDK FilterObject filter = Filters.eq("invite", "rejected"); int offset = 0; int limit = 10; QuerySorter<Channel> sort = new QuerySortByField<>(); int messageLimit = 0; int memberLimit = 0; QueryChannelsRequest request = new QueryChannelsRequest(filter, offset, limit, sort, messageLimit, memberLimit);  client.queryChannels(request).enqueue(result -> {  if (result.isSuccess()) {  List<Channel> channels = result.data();  } else {  // Handle result.error()  } });  // Backend SDK Channel.queryMembers()  .type("messaging")  .id("general")  .filterCondition("invite", "rejected")  .request();

var filter = new List<IFieldFilterRule> {  ChannelFilter.Invite.EqualsTo(ChannelFieldInvite.Status.Rejected) };  var sort = ChannelSort.OrderByDescending(ChannelSortFieldName.LastMessageAt);  var rejectedInvites = await Client.QueryChannelsAsync(filter, sort);

Query Pending Invites

val request = QueryChannelsRequest(  filter = Filters.eq("invite", "pending"),  offset = 0,  limit = 10 ) client.queryChannels(request).enqueue { result ->  if (result is Result.Success) {  val channels: List<Channel> = result.value  } else {  // Handle Result.Failure  } }

const rejected = client.queryChannels({  invite: "pending", });  //server side (query invites for user rob) const invites = await client.queryChannels(  {  invite: "pending",  },  {},  { user_id: "rob" }, );

$invites = $client->queryChannels(['invite' => 'pending'],[], ['user_id' => 'jenny']);

final rejected = await client.queryChannels(filter: {"invite": "pending"});

import StreamChat  let controller = chatClient.channelListController(  query: .init(  filter: .equal(.invite, to: .pending)  ) )  controller.synchronize { error in  if let error = error {  // handle error  print(error)  } else {  // access channels  print(controller.channels)   // load more if needed  controller.loadNextChannels(limit: 10) { _ in  // handle error / access channels  }  } }

Client->QueryChannels(FFilter::Equal(TEXT("invite"), TEXT("pending")));

await channelClient.QueryChannelsAsync(QueryChannelsOptions.Default.WithFilter(new Dictionary<string, object> {  { "invite", "pending" }, }));

client.query_channels({"invite": "pending"})

client.query_channels({ 'invite' => 'pending' })

client.QueryChannels(ctx, &QueryOption{ Filter: map[string]interface{}{ "invite": "pending", }, })

FilterObject filter = Filters.eq("invite", "pending"); int offset = 0; int limit = 10; QuerySorter<Channel> sort = new QuerySortByField<>(); int messageLimit = 0; int memberLimit = 0; QueryChannelsRequest request = new QueryChannelsRequest(filter, offset, limit, sort, messageLimit, memberLimit);  client.queryChannels(request).enqueue(result -> {  if (result.isSuccess()) {  List<Channel> channels = result.data();  } else {  // Handle result.error()  } });

var filter = new List<IFieldFilterRule> {  ChannelFilter.Invite.EqualsTo(ChannelFieldInvite.Status.Pending) };  var sort = ChannelSort.OrderByDescending(ChannelSortFieldName.LastMessageAt);  var pendingInvites = await Client.QueryChannelsAsync(filter, sort);

Truncate Channel

Messages Overview