# 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

<codetabs>

<codetabs-item value="kotlin" label="Kotlin">

```kotlin
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
  }
}
```

</codetabs-item>

<codetabs-item value="javascript" label="JavaScript">

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

</codetabs-item>

<codetabs-item value="php" label="PHP">

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

</codetabs-item>

<codetabs-item value="dart" label="Dart">

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

await invite.create();
```

</codetabs-item>

<codetabs-item value="swift" label="Swift">

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

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

</codetabs-item>

<codetabs-item value="unreal" label="Unreal">

```cpp
// Not yet supported in the Unreal SDK
```

</codetabs-item>

<codetabs-item value="python" label="Python">

```python
from getstream.models import ChannelMemberRequest

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

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

</codetabs-item>

<codetabs-item value="ruby" label="Ruby">

```ruby
require 'getstream_ruby'

Models = GetStream::Generated::Models

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

</codetabs-item>

<codetabs-item value="go" label="Go">

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

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

</codetabs-item>

<codetabs-item value="csharp" label="C#">

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

</codetabs-item>

<codetabs-item value="java" label="Java">

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

</codetabs-item>

<codetabs-item value="unity" label="Unity">

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

</codetabs-item>

</codetabs>

## 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!").

<codetabs>

<codetabs-item value="kotlin" label="Kotlin">

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

</codetabs-item>

<codetabs-item value="javascript" label="JavaScript">

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

</codetabs-item>

<codetabs-item value="php" label="PHP">

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

</codetabs-item>

<codetabs-item value="dart" label="Dart">

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

</codetabs-item>

<codetabs-item value="swift" label="Swift">

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


controller.acceptInvite()
```

</codetabs-item>

<codetabs-item value="unreal" label="Unreal">

```cpp
// Not yet supported in the Unreal SDK
```

</codetabs-item>

<codetabs-item value="csharp" label="C#">

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

</codetabs-item>

<codetabs-item value="python" label="Python">

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

</codetabs-item>

<codetabs-item value="ruby" label="Ruby">

```ruby
require 'getstream_ruby'

Models = GetStream::Generated::Models

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

</codetabs-item>

<codetabs-item value="go" label="Go">

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

</codetabs-item>

<codetabs-item value="java" label="Java">

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

</codetabs-item>

<codetabs-item value="unity" label="Unity">

```csharp
await channel.AcceptInviteAsync();
```

</codetabs-item>

</codetabs>

## 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.

<codetabs>

<codetabs-item value="kotlin" label="Kotlin">

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

</codetabs-item>

<codetabs-item value="javascript" label="JavaScript">

```js
await channel.rejectInvite();

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

</codetabs-item>

<codetabs-item value="php" label="PHP">

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

</codetabs-item>

<codetabs-item value="dart" label="Dart">

```dart
await channel.rejectInvite();
```

</codetabs-item>

<codetabs-item value="swift" label="Swift">

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

controller.rejectInvite()
```

</codetabs-item>

<codetabs-item value="unreal" label="Unreal">

```cpp
// Not yet supported in the Unreal SDK
```

</codetabs-item>

<codetabs-item value="csharp" label="C#">

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

</codetabs-item>

<codetabs-item value="python" label="Python">

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

</codetabs-item>

<codetabs-item value="ruby" label="Ruby">

```ruby
require 'getstream_ruby'

Models = GetStream::Generated::Models

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

</codetabs-item>

<codetabs-item value="go" label="Go">

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

</codetabs-item>

<codetabs-item value="java" label="Java">

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

</codetabs-item>

<codetabs-item value="unity" label="Unity">

```csharp
await channel.RejectInviteAsync();
```

</codetabs-item>

</codetabs>

## 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

<codetabs>

<codetabs-item value="kotlin" label="Kotlin">

```kotlin
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
  }
}
```

</codetabs-item>

<codetabs-item value="javascript" label="JavaScript">

```js
const invites = await client.queryChannels({
  invite: "accepted",
});

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

</codetabs-item>

<codetabs-item value="php" label="PHP">

```php
$response = $client->queryChannels(new Models\QueryChannelsRequest(
    filterConditions: (object)["invite" => "accepted"],
    userID: "jenny",
));
```

</codetabs-item>

<codetabs-item value="dart" label="Dart">

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

</codetabs-item>

<codetabs-item value="swift" label="Swift">

```swift
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
    }
  }
}
```

</codetabs-item>

<codetabs-item value="unreal" label="Unreal">

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

</codetabs-item>

<codetabs-item value="csharp" label="C#">

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

</codetabs-item>

<codetabs-item value="python" label="Python">

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

</codetabs-item>

<codetabs-item value="ruby" label="Ruby">

```ruby
require 'getstream_ruby'

Models = GetStream::Generated::Models

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

</codetabs-item>

<codetabs-item value="go" label="Go">

```go
client.Chat().QueryChannels(ctx, &getstream.QueryChannelsRequest{
	FilterConditions: map[string]any{"invite": "accepted"},
})
```

</codetabs-item>

<codetabs-item value="java" label="Java">

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

</codetabs-item>

<codetabs-item value="unity" label="Unity">

```csharp
var filter = new List<IFieldFilterRule>
{
  ChannelFilter.Invite.EqualsTo(ChannelFieldInvite.Status.Accepted)
};

var sort = ChannelSort.OrderByDescending(ChannelSortFieldName.LastMessageAt);

var acceptedInvites = await Client.QueryChannelsAsync(filter, sort);
```

</codetabs-item>

</codetabs>

### Query Rejected Invites

<codetabs>

<codetabs-item value="kotlin" label="Kotlin">

```kotlin
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
  }
}
```

</codetabs-item>

<codetabs-item value="javascript" label="JavaScript">

```js
const rejected = client.queryChannels({
  invite: "rejected",
});

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

</codetabs-item>

<codetabs-item value="php" label="PHP">

```php
$response = $client->queryChannels(new Models\QueryChannelsRequest(
    filterConditions: (object)["invite" => "rejected"],
    userID: "jenny",
));
```

</codetabs-item>

<codetabs-item value="dart" label="Dart">

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

</codetabs-item>

<codetabs-item value="swift" label="Swift">

```swift
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
    }
  }
}
```

</codetabs-item>

<codetabs-item value="unreal" label="Unreal">

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

</codetabs-item>

<codetabs-item value="csharp" label="C#">

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

</codetabs-item>

<codetabs-item value="python" label="Python">

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

</codetabs-item>

<codetabs-item value="ruby" label="Ruby">

```ruby
require 'getstream_ruby'

Models = GetStream::Generated::Models

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

</codetabs-item>

<codetabs-item value="go" label="Go">

```go
client.Chat().QueryChannels(ctx, &getstream.QueryChannelsRequest{
	FilterConditions: map[string]any{"invite": "rejected"},
})
```

</codetabs-item>

<codetabs-item value="java" label="Java">

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

</codetabs-item>

<codetabs-item value="unity" label="Unity">

```csharp
var filter = new List<IFieldFilterRule>
{
  ChannelFilter.Invite.EqualsTo(ChannelFieldInvite.Status.Rejected)
};

var sort = ChannelSort.OrderByDescending(ChannelSortFieldName.LastMessageAt);

var rejectedInvites = await Client.QueryChannelsAsync(filter, sort);
```

</codetabs-item>

</codetabs>

### Query Pending Invites

<codetabs>

<codetabs-item value="kotlin" label="Kotlin">

```kotlin
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
  }
}
```

</codetabs-item>

<codetabs-item value="javascript" label="JavaScript">

```js
const rejected = client.queryChannels({
  invite: "pending",
});

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

</codetabs-item>

<codetabs-item value="php" label="PHP">

```php
$response = $client->queryChannels(new Models\QueryChannelsRequest(
    filterConditions: (object)["invite" => "pending"],
    userID: "jenny",
));
```

</codetabs-item>

<codetabs-item value="dart" label="Dart">

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

</codetabs-item>

<codetabs-item value="swift" label="Swift">

```swift
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
    }
  }
}
```

</codetabs-item>

<codetabs-item value="unreal" label="Unreal">

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

</codetabs-item>

<codetabs-item value="csharp" label="C#">

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

</codetabs-item>

<codetabs-item value="python" label="Python">

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

</codetabs-item>

<codetabs-item value="ruby" label="Ruby">

```ruby
require 'getstream_ruby'

Models = GetStream::Generated::Models

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

</codetabs-item>

<codetabs-item value="go" label="Go">

```go
client.Chat().QueryChannels(ctx, &getstream.QueryChannelsRequest{
	FilterConditions: map[string]any{"invite": "pending"},
})
```

</codetabs-item>

<codetabs-item value="java" label="Java">

```java
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()
  }
});
```

</codetabs-item>

<codetabs-item value="unity" label="Unity">

```csharp
var filter = new List<IFieldFilterRule>
{
  ChannelFilter.Invite.EqualsTo(ChannelFieldInvite.Status.Pending)
};

var sort = ChannelSort.OrderByDescending(ChannelSortFieldName.LastMessageAt);

var pendingInvites = await Client.QueryChannelsAsync(filter, sort);
```

</codetabs-item>

</codetabs>


---

This page was last updated at 2026-03-12T08:54:36.707Z.

For the most recent version of this documentation, visit [https://getstream.io/chat/docs/ruby/channel_invites/](https://getstream.io/chat/docs/ruby/channel_invites/).