Invites

Inviting Users

Stream Chat provides the ability to invite users to a channel. Upon invitation, the end-user will receive a notification that they were invited to the specified channel.

Most of our SDKs have a helper method for member invitation which uses the Update Channel API endpoint.

See the following for an example on how to invite a user by user ID:

val channelClient = client.channel("messaging", "general")
val data = mapOf("invites" to listOf("nick"))

channelClient.create(memberIds = listOf("thierry", "tommaso"), extraData = data).enqueue { result ->
  if (result.isSuccess) {
    val channel = result.data()
  } else {
    // Handle result.error()
  }
}

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

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

In order to accept an invite, you must use call the acceptInvite method. The acceptInvite method accepts an object with an optional message property. Please see below for an example of how to call acceptInvite :

The message can be used for system messages for display within the channel (e.g. “Nick joined this channel!”).

Unread counts are not incremented for a channel for which a user is a member of but has a pending invite.

channelClient.acceptInvite(
  message = "Nick joined this channel!"
).enqueue { result ->
  if (result.isSuccess) {
    val channel = result.data()
  } else {
    // Handle result.error()
  }
}

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

Rejecting an Invite

To reject an invite, call the rejectInvite method. This method does not require a user ID as it pulls the user ID from the current session in store from the connectUser call.

channelClient.rejectInvite().enqueue { result -> 
  if (result.isSuccess) { 
    // Invite rejected 
  } else { 
    // Handle result.error() 
  } 
}

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 for Accepted Invites

Querying for accepted invites is done via the queryChannels method. This allows you to return a list of accepted invites with a single call. See below for an example:

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

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 for Rejected Invites

Similar to querying for accepted invites, you can query for rejected invites with queryChannels. See below for an example:

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

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

// Andoid 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 for Pending Invites

Similar to querying for accepted and rejected invites, you can query for pending invites with queryChannels. See below for an example:

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

// Backend SDK
Channel.queryMembers()
  .type("messaging")
  .id("general")
  .filterCondition("invite", "pending")
  .request();

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

Channel Capabilities

Muting or Hiding Channels