# 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
```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
}
}
```
```js
await channel.inviteMembers(["nick"]);
```
```php
$channel->inviteMembers(['thierry']);
```
```dart
final invite = client.channel("messaging", id: "awesome-chat",
extraData: {
"name": "Founder Chat",
"members": ["thierry", "tommaso"],
"invites": ["nick"],
});
await invite.create();
```
```swift
let controller = client.channelController(for: .init(type: .messaging, id: "general"))
controller.inviteMembers(userIds: ["thierry"])
```
```cpp
// Not yet supported in the Unreal SDK
```
```python
channel.invite_members(["thierry"])
```
```ruby
# require 'stream-chat'
channel.invite_members(['thierry'])
```
```go
channel.InviteMembers(ctx, "thierry")
```
```csharp
await channelClient.InviteAsync("", "", "thierry");
```
```java
// Android SDK
ChannelClient channelClient = client.channel("messaging", "general");
List memberIds = Arrays.asList("thierry", "tommaso");
Map 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();
```
```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");
```
## 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!").
```kotlin
channelClient.acceptInvite(
message = "Nick joined this channel!"
).enqueue { result ->
if (result is Result.Success) {
val channel: Channel = result.value
} else {
// Handle Result.Failure
}
}
```
```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" });
```
```php
// initialize the channel
$channel = $client->Channel('messaging', 'team-chat-5');
// accept the invite
$accept = $channel->acceptInvite(['user_id'=>'elon']);
```
```dart
final channel = client.channel("messaging", id: "awesome-chat");
await channel.acceptInvite();
```
```swift
let controller = client.channelController(for: .init(type: .messaging, id: "general"))
controller.acceptInvite()
```
```cpp
// Not yet supported in the Unreal SDK
```
```csharp
await channelClient.AcceptInviteAsync("", "", "thierry");
```
```python
channel.accept_invite("thierry")
```
```ruby
channel.accept_invite("thierry")
```
```go
channel.AcceptInvite(ctx, "thierry", nil)
```
```java
// 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();
```
```csharp
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.
```kotlin
channelClient.rejectInvite().enqueue { result ->
if (result is Result.Success) {
// Invite rejected
} else {
// Handle Result.Failure
}
}
```
```js
await channel.rejectInvite();
//server side
await channel.rejectInvite({ user_id: "rob" });
```
```php
$reject = $channel->rejectInvite(['user_id'=>'elon']);
```
```dart
await channel.rejectInvite();
```
```swift
let controller = client.channelController(for: .init(type: .messaging, id: "general"))
controller.rejectInvite()
```
```cpp
// Not yet supported in the Unreal SDK
```
```csharp
await channelClient.RejectInviteAsync("", "", "thierry");
```
```python
channel.reject_invite("thierry")
```
```ruby
channel.reject_invite("thierry")
```
```go
channel.RejectInvite(ctx, "thierry", nil)
```
```java
// 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();
```
```csharp
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
```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 = result.value
} else {
// Handle Result.Failure
}
}
```
```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" },
);
```
```php
$invites = $client->queryChannels(['invite' => 'accepted'],[], ['user_id' => 'jenny']);
```
```dart
final invites = await client.queryChannels(filter: {"invite": "accepted"});
```
```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
}
}
}
```
```cpp
Client->QueryChannels(FFilter::Equal(TEXT("invite"), TEXT("accepted")));
```
```csharp
await channelClient.QueryChannelsAsync(QueryChannelsOptions.Default.WithFilter(new Dictionary
{
{ "invite", "accepted" },
}));
```
```python
client.query_channels({"invite": "accepted"})
```
```ruby
client.query_channels({ 'invite' => 'accepted' })
```
```go
client.QueryChannels(ctx, &QueryOption{
Filter: map[string]interface{}{
"invite": "accepted",
},
})
```
```java
// Android SDK
FilterObject filter = Filters.eq("invite", "accepted");
int offset = 0;
int limit = 10;
QuerySorter 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 channels = result.data();
} else {
// Handle result.error()
}
});
// Backend SDK
Channel.queryMembers().type("messaging").id("general").filterCondition("invite", "accepted").request();
```
```csharp
var filter = new List
{
ChannelFilter.Invite.EqualsTo(ChannelFieldInvite.Status.Accepted)
};
var sort = ChannelSort.OrderByDescending(ChannelSortFieldName.LastMessageAt);
var acceptedInvites = await Client.QueryChannelsAsync(filter, sort);
```
### Query Rejected Invites
```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 = result.value
} else {
// Handle Result.Failure
}
}
```
```js
const rejected = client.queryChannels({
invite: "rejected",
});
//server side (query invites for user rob)
const invites = await client.queryChannels(
{
invite: "rejected",
},
{},
{ user_id: "rob" },
);
```
```php
$invites = $client->queryChannels(['invite' => 'rejected'],[], ['user_id' => 'jenny']);
```
```dart
final rejected = await client.queryChannels(filter: {"invite": "rejected"});
```
```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
}
}
}
```
```cpp
Client->QueryChannels(FFilter::Equal(TEXT("invite"), TEXT("rejected")));
```
```csharp
await channelClient.QueryChannelsAsync(QueryChannelsOptions.Default.WithFilter(new Dictionary
{
{ "invite", "rejected" },
}));
```
```python
client.query_channels({"invite": "rejected"})
```
```ruby
client.query_channels({ 'invite' => 'rejected' })
```
```go
client.QueryChannels(ctx, &QueryOption{
Filter: map[string]interface{}{
"invite": "rejected",
},
})
```
```java
// Android SDK
FilterObject filter = Filters.eq("invite", "rejected");
int offset = 0;
int limit = 10;
QuerySorter 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 channels = result.data();
} else {
// Handle result.error()
}
});
// Backend SDK
Channel.queryMembers()
.type("messaging")
.id("general")
.filterCondition("invite", "rejected")
.request();
```
```csharp
var filter = new List
{
ChannelFilter.Invite.EqualsTo(ChannelFieldInvite.Status.Rejected)
};
var sort = ChannelSort.OrderByDescending(ChannelSortFieldName.LastMessageAt);
var rejectedInvites = await Client.QueryChannelsAsync(filter, sort);
```
### Query Pending Invites
```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 = result.value
} else {
// Handle Result.Failure
}
}
```
```js
const rejected = client.queryChannels({
invite: "pending",
});
//server side (query invites for user rob)
const invites = await client.queryChannels(
{
invite: "pending",
},
{},
{ user_id: "rob" },
);
```
```php
$invites = $client->queryChannels(['invite' => 'pending'],[], ['user_id' => 'jenny']);
```
```dart
final rejected = await client.queryChannels(filter: {"invite": "pending"});
```
```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
}
}
}
```
```cpp
Client->QueryChannels(FFilter::Equal(TEXT("invite"), TEXT("pending")));
```
```csharp
await channelClient.QueryChannelsAsync(QueryChannelsOptions.Default.WithFilter(new Dictionary
{
{ "invite", "pending" },
}));
```
```python
client.query_channels({"invite": "pending"})
```
```ruby
client.query_channels({ 'invite' => 'pending' })
```
```go
client.QueryChannels(ctx, &QueryOption{
Filter: map[string]interface{}{
"invite": "pending",
},
})
```
```java
FilterObject filter = Filters.eq("invite", "pending");
int offset = 0;
int limit = 10;
QuerySorter 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 channels = result.data();
} else {
// Handle result.error()
}
});
```
```csharp
var filter = new List
{
ChannelFilter.Invite.EqualsTo(ChannelFieldInvite.Status.Pending)
};
var sort = ChannelSort.OrderByDescending(ChannelSortFieldName.LastMessageAt);
var pendingInvites = await Client.QueryChannelsAsync(filter, sort);
```
---
This page was last updated at 2026-03-05T19:05:24.072Z.
For the most recent version of this documentation, visit [https://getstream.io/chat/docs/go-golang/channel_invites/](https://getstream.io/chat/docs/go-golang/channel_invites/).