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

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

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

$client->updateChannel("messaging", "team-chat-5", new Models\UpdateChannelRequest(
    invites: [new Models\ChannelMemberRequest(userID: "thierry")],
));

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

await invite.create();

import StreamChat

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

// Controllers

controller.inviteMembers(userIds: ["thierry"])

// State layer (async-await)

try await chat.inviteMembers(["thierry"])

// Not yet supported in the Unreal SDK

from getstream.models import ChannelMemberRequest

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

channel.update(invites=[ChannelMemberRequest(user_id="thierry")])

require 'getstream_ruby'

Models = GetStream::Generated::Models

client.chat.update_channel("messaging", "general", Models::UpdateChannelRequest.new(
  invites: [Models::ChannelMemberRequest.new(user_id: 'thierry')]
))

channel := client.Chat().Channel("messaging", "general")

channel.Update(ctx, &getstream.UpdateChannelRequest{
	Invites: []getstream.ChannelMemberRequest{{UserID: "thierry"}},
})

using GetStream;
using GetStream.Models;

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

var channelId = "channel-id";

// Send invites
await chat.UpdateChannelAsync("messaging", channelId,
    new UpdateChannelRequest
    {
        Invites = new List<ChannelMemberRequest>
        {
            new ChannelMemberRequest { UserID = "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
chat.updateChannel("messaging", "general", UpdateChannelRequest.builder()
    .invites(List.of(
        ChannelMemberRequest.builder().userID("thierry").build(),
        ChannelMemberRequest.builder().userID("tommaso").build()))
    .build()).execute();

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

// Accept the invite
$client->updateChannel("messaging", "team-chat-5", new Models\UpdateChannelRequest(
    acceptInvite: true,
    userID: "elon",
));

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

import StreamChat

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

// Controllers

controller.acceptInvite(message: "Nick joined this channel!")

// State layer (async-await)

try await chat.acceptInvite(with: "Nick joined this channel!")

// Not yet supported in the Unreal SDK

using GetStream;
using GetStream.Models;

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

var channelId = "channel-id";

// Accept invite
await chat.UpdateChannelAsync("messaging", channelId,
    new UpdateChannelRequest
    {
        AcceptInvite = true,
        UserID = "thierry"
    });

channel.update(accept_invite=True, user_id="thierry")

require 'getstream_ruby'

Models = GetStream::Generated::Models

client.chat.update_channel("messaging", "general", Models::UpdateChannelRequest.new(
  accept_invite: true,
  user_id: 'thierry'
))

channel.Update(ctx, &getstream.UpdateChannelRequest{
	AcceptInvite: getstream.PtrTo(true),
	UserID:       getstream.PtrTo("thierry"),
})

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

// Backend SDK
chat.updateChannel("messaging", "general", UpdateChannelRequest.builder()
    .acceptInvite(true)
    .userID("nick")
    .message(MessageRequest.builder().text("Nick joined the channel").userID("nick").build())
    .build()).execute();

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 the invite
$client->updateChannel("messaging", "team-chat-5", new Models\UpdateChannelRequest(
    rejectInvite: true,
    userID: "elon",
));

await channel.rejectInvite();

import StreamChat

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

// Controllers

controller.rejectInvite()

// State layer (async-await)

try await chat.rejectInvite()

// Not yet supported in the Unreal SDK

using GetStream;
using GetStream.Models;

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

var channelId = "channel-id";

// Reject invite
await chat.UpdateChannelAsync("messaging", channelId,
    new UpdateChannelRequest
    {
        RejectInvite = true,
        UserID = "thierry"
    });

channel.update(reject_invite=True, user_id="thierry")

require 'getstream_ruby'

Models = GetStream::Generated::Models

client.chat.update_channel("messaging", "general", Models::UpdateChannelRequest.new(
  reject_invite: true,
  user_id: 'thierry'
))

channel.Update(ctx, &getstream.UpdateChannelRequest{
	RejectInvite: getstream.PtrTo(true),
	UserID:       getstream.PtrTo("thierry"),
})

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

// Backend SDK
chat.updateChannel("messaging", "general", UpdateChannelRequest.builder()
    .rejectInvite(true)
    .userID("nick")
    .build()).execute();

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

$response = $client->queryChannels(new Models\QueryChannelsRequest(
    filterConditions: (object)["invite" => "accepted"],
    userID: "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")));

using GetStream;
using GetStream.Models;

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

// Query accepted invites
await chat.QueryChannelsAsync(new QueryChannelsRequest
{
    FilterConditions = new Dictionary<string, object>
    {
        { "invite", "accepted" }
    }
});

client.chat.query_channels(filter_conditions={"invite": "accepted"})

require 'getstream_ruby'

Models = GetStream::Generated::Models

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

client.Chat().QueryChannels(ctx, &getstream.QueryChannelsRequest{
	FilterConditions: map[string]any{"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
chat.queryChannels(QueryChannelsRequest.builder()
    .filterConditions(Map.of("invite", "accepted"))
    .build()).execute();

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

$response = $client->queryChannels(new Models\QueryChannelsRequest(
    filterConditions: (object)["invite" => "rejected"],
    userID: "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")));

using GetStream;
using GetStream.Models;

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

// Query rejected invites
await chat.QueryChannelsAsync(new QueryChannelsRequest
{
    FilterConditions = new Dictionary<string, object>
    {
        { "invite", "rejected" }
    }
});

client.chat.query_channels(filter_conditions={"invite": "rejected"})

require 'getstream_ruby'

Models = GetStream::Generated::Models

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

client.Chat().QueryChannels(ctx, &getstream.QueryChannelsRequest{
	FilterConditions: map[string]any{"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
chat.queryChannels(QueryChannelsRequest.builder()
    .filterConditions(Map.of("invite", "rejected"))
    .build()).execute();

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

$response = $client->queryChannels(new Models\QueryChannelsRequest(
    filterConditions: (object)["invite" => "pending"],
    userID: "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")));

using GetStream;
using GetStream.Models;

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

// Query pending invites
await chat.QueryChannelsAsync(new QueryChannelsRequest
{
    FilterConditions = new Dictionary<string, object>
    {
        { "invite", "pending" }
    }
});

client.chat.query_channels(filter_conditions={"invite": "pending"})

require 'getstream_ruby'

Models = GetStream::Generated::Models

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

client.Chat().QueryChannels(ctx, &getstream.QueryChannelsRequest{
	FilterConditions: map[string]any{"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