# Channel Members
Channel members are users who have been added to a channel and can participate in conversations. This page covers how to manage channel membership, including adding and removing members, controlling message history visibility, and managing member roles.
## Adding and Removing Members
### Adding Members
Using the `addMembers()` method adds the given users as members to a channel.
```kotlin label="Kotlin"
val channelClient = client.channel("messaging", "general")
// Add members with ids "thierry" and "josh"
channelClient.addMembers(listOf("thierry", "josh")).enqueue { result ->
if (result is Result.Success) {
val channel: Channel = result.value
} else {
// Handle Result.Failure
}
}
// Add member "thierry" with custom data with key: "code_name" and value "007"
val params = AddMembersParams(
members = listOf(
MemberData(userId = "thierry", extraData = mapOf("code_name" to "007")),
),
)
channelClient.addMembers(params).enqueue { result ->
if (result is Result.Success) {
val channel: Channel = result.value
} else {
// Handle Result.Failure
}
}
```
```js label="JavaScript"
await channel.addMembers(["thierry", "josh"]);
// Add user to the channel with role set
await channel.addMembers([
{ user_id: "james_bond", channel_role: "channel_moderator" },
]);
// Add new channel member with custom data
await channel.addMembers([{ user_id: "james_bond", code_name: "007" }]);
```
```dart label="Dart"
await channel.addMembers(["thierry", "josh"]);
```
```php label="PHP"
use GetStream\ChatClient;
use GetStream\GeneratedModels as Models;
$client->updateChannel("messaging", "channel-id", new Models\UpdateChannelRequest(
addMembers: [
new Models\ChannelMemberRequest(userID: "thierry"),
new Models\ChannelMemberRequest(userID: "jenny"),
],
));
```
```swift label="Swift"
import StreamChat
let controller = chatClient.channelController(for: .init(type: .messaging, id: "general"))
// Controllers
controller.addMembers(userIds: ["thierry", "josh"])
// State layer (async-await)
try await chat.addMembers(["thierry", "josh"])
```
```go label="Go"
channel := client.Chat().Channel("messaging", "general")
channel.Update(ctx, &getstream.UpdateChannelRequest{
AddMembers: []getstream.ChannelMemberRequest{
{UserID: "thierry"},
{UserID: "josh"},
},
})
```
```cpp label="Unreal"
Channel->AddMembers({TEXT("thierry"), TEXT("josh")});
```
```python label="Python"
from getstream.models import ChannelMemberRequest
channel.update(
add_members=[
ChannelMemberRequest(user_id="thierry"),
ChannelMemberRequest(user_id="josh"),
],
)
```
```csharp label="C#"
using GetStream;
using GetStream.Models;
var client = new StreamClient("{{ api_key }}", "{{ api_secret }}");
var chat = new ChatClient(client);
await chat.UpdateChannelAsync("messaging", channelId,
new UpdateChannelRequest
{
AddMembers = new List
{
new ChannelMemberRequest { UserID = "thierry" },
new ChannelMemberRequest { UserID = "josh" }
}
});
```
```ruby label="Ruby"
require 'getstream_ruby'
Models = GetStream::Generated::Models
client.chat.update_channel("messaging", "channel-id", Models::UpdateChannelRequest.new(
add_members: [
Models::ChannelMemberRequest.new(user_id: "thierry"),
Models::ChannelMemberRequest.new(user_id: "josh"),
],
))
```
```java label="Java"
// Android SDK
ChannelClient channelClient = client.channel("messaging", "general");
// Add members with ids "thierry" and "josh"
channelClient.addMembers(Arrays.asList("thierry", "josh"), null).enqueue(result -> {
if (result.isSuccess()) {
Channel channel = result.data();
} else {
// Handle result.error()
}
});
// Backend SDK
chat.updateChannel("messaging", "general", UpdateChannelRequest.builder()
.addMembers(List.of(
ChannelMemberRequest.builder().userID("thierry").build(),
ChannelMemberRequest.builder().userID("josh").build()))
.build()).execute();
```
```csharp label="Unity"
var channel = await Client.GetOrCreateChannelWithIdAsync(ChannelType.Messaging, channelId: "my-channel-id");
// Add IStreamUser collection as members
await channel.AddMembersAsync(users);
// Or add by ID
await channel.AddMembersAsync("some-user-id-1", "some-user-id-2");
```
**Note:** You can only add/remove up to 100 members at once.
Members can also be added when creating a channel:
```kotlin label="Kotlin"
val channelClient = client.channel("messaging", "general")
// Add members during channel creation
channelClient.create(
memberIds = listOf("james_bond", "alec_trevelyan", "bill_fairbanks"),
extraData = emptyMap(),
).enqueue()
// Add members with custom extra data during channel creation
val params = CreateChannelParams(
members = listOf(
MemberData(userId = "james_bond", extraData = mapOf("code_name" to "007")),
MemberData(userId = "alec_trevelyan", extraData = mapOf("code_name" to "006")),
),
extraData = emptyMap(),
)
channelClient.create(params).enqueue()
```
```js label="JavaScript"
const channel = client.channel("messaging", randomID, {
members: [
{ user_id: "james_bond", code_name: "007" },
{ user_id: "alec_trevelyan", code_name: "006" },
],
});
await channel.create();
```
```swift label="Swift"
let channelId = ChannelId(type: .messaging, id: "general")
let channelController = try chatClient.channelController(
createChannelWithId: channelId,
members: ["thierry", "tommaso"]
)
channelController.synchronize { error in
if let error = error {
print(error)
}
}
```
```csharp label="C#"
// Members can be added when creating a channel
var resp = await chat.GetOrCreateChannelAsync("messaging", "my-channel-id",
new ChannelGetOrCreateRequest
{
Data = new ChannelInput
{
CreatedByID = "user-1",
Members = new List
{
new ChannelMemberRequest { UserID = "user-1" },
new ChannelMemberRequest { UserID = "user-2" },
new ChannelMemberRequest { UserID = "user-3" }
}
}
});
```
### Removing Members
Using the `removeMembers()` method removes the given users from the channel.
```kotlin label="Kotlin"
// Remove member with id "tommaso"
channelClient.removeMembers(listOf("tommaso")).enqueue { result ->
if (result is Result.Success) {
val channel: Channel = result.value
} else {
// Handle Result.Failure
}
}
```
```js label="JavaScript"
await channel.removeMembers(["tommaso"]);
```
```dart label="Dart"
await channel.removeMembers(["tommaso"]);
```
```php label="PHP"
use GetStream\ChatClient;
use GetStream\GeneratedModels as Models;
$client->updateChannel("messaging", "channel-id", new Models\UpdateChannelRequest(
removeMembers: ["thierry", "jenny"],
));
```
```swift label="Swift"
// Controllers
controller.removeMembers(userIds: ["tommaso"])
// State layer (async-await)
try await chat.removeMembers(["tommaso"])
```
```cpp label="Unreal"
Channel->RemoveMembers({TEXT("tommaso")});
```
```python label="Python"
channel.update(remove_members=["tommaso"])
```
```csharp label="C#"
await chat.UpdateChannelAsync("messaging", channelId,
new UpdateChannelRequest
{
RemoveMembers = new List { "thierry", "josh" }
});
```
```ruby label="Ruby"
require 'getstream_ruby'
Models = GetStream::Generated::Models
client.chat.update_channel("messaging", "channel-id", Models::UpdateChannelRequest.new(
remove_members: ["tommaso"],
))
```
```java label="Java"
// Android SDK
channelClient.removeMembers(Arrays.asList("tommaso"), null).enqueue(result -> {
if (result.isSuccess()) {
Channel channel = result.data();
} else {
// Handle result.error()
}
});
// Backend SDK
chat.updateChannel("messaging", "general", UpdateChannelRequest.builder()
.removeMembers(List.of("tommaso"))
.build()).execute();
```
```csharp label="Unity"
// Access channel members via channel.Members
var member = channel.Members.First();
await channel.RemoveMembersAsync(member);
// Remove by user ID
await channel.RemoveMembersAsync("some-user-id-1", "some-user-id-2");
```
```go label="Go"
channel.Update(ctx, &getstream.UpdateChannelRequest{
RemoveMembers: []string{"tommaso"},
})
```
### Leaving a Channel
Users can leave a channel without moderator-level permissions. Ensure channel members have the `Leave Own Channel` permission enabled.
```kotlin label="Kotlin"
channelClient.removeMembers(listOf("my_user_id")).enqueue()
```
```js label="JavaScript"
// Remove own channel membership
await channel.removeMembers(["my_user_id"]);
```
```swift label="Swift"
channelController.removeMembers(userIds: ["john"]) { error in
// …
}
```
```cpp label="Unreal"
Channel->RemoveMembers({TEXT("my-user-id")});
```
```csharp label="Unity"
await channel.RemoveMembersAsync(member);
```
You can familiarize yourself with all permissions in the [Permissions section](/chat/docs/javascript/chat-permission-policies/).
## Hide History
When members join a channel, you can specify whether they have access to the channel's message history. By default, new members can see the history. Set `hide_history` to `true` to hide it for new members.
```kotlin label="Kotlin"
// Add members by their IDs with hideHistory=true
channelClient.addMembers(
memberIds = listOf("thierry"),
hideHistory = true,
).enqueue()
// Add members by their IDs with hideHistory=true and custom extra data
val params = AddMembersParams(
members = listOf(
MemberData(userId = "thierry", extraData = mapOf("new_member" to true)),
),
hideHistory = true,
)
channelClient.addMembers(params).enqueue()
```
```js label="JavaScript"
await channel.addMembers(["thierry"], undefined, { hide_history: true });
```
```go label="Go"
channel.Update(ctx, &getstream.UpdateChannelRequest{
AddMembers: []getstream.ChannelMemberRequest{{UserID: "thierry"}},
HideHistory: getstream.PtrTo(true),
})
```
```python label="Python"
from getstream.models import ChannelMemberRequest
channel.update(
add_members=[ChannelMemberRequest(user_id="thierry")],
hide_history=True,
)
```
```php label="PHP"
use GetStream\ChatClient;
use GetStream\GeneratedModels as Models;
$client->updateChannel("messaging", "channel-id", new Models\UpdateChannelRequest(
addMembers: [new Models\ChannelMemberRequest(userID: "thierry")],
hideHistory: true,
));
```
```csharp label="C#"
await chat.UpdateChannelAsync("messaging", channelId,
new UpdateChannelRequest
{
AddMembers = new List
{
new ChannelMemberRequest { UserID = "thierry" }
},
HideHistory = true
});
```
```ruby label="Ruby"
require 'getstream_ruby'
Models = GetStream::Generated::Models
client.chat.update_channel("messaging", "channel-id", Models::UpdateChannelRequest.new(
add_members: [
Models::ChannelMemberRequest.new(user_id: "tommaso"),
Models::ChannelMemberRequest.new(user_id: "josh"),
],
hide_history: true,
))
```
```java label="Java"
// Backend SDK
chat.updateChannel("channel-type", "channel-id", UpdateChannelRequest.builder()
.addMembers(List.of(ChannelMemberRequest.builder().userID("thierry").build()))
.hideHistory(true)
.build()).execute();
```
```csharp label="Unity"
await channel.AddMembersAsync(users, hideHistory: true);
```
```swift label="Swift"
// Controllers
channelController.addMembers(
userIds: ["thierry"],
hideHistory: true
) { error in
// …
}
// State layer (async-await)
try await chat.addMembers(["thierry"], hideHistory: true)
```
### Hide History Before a Specific Date
Alternatively, `hide_history_before` can be used to hide any history before a given timestamp while giving members access to later messages. The value must be a timestamp in the past in RFC 3339 format. If both parameters are defined, `hide_history_before` takes precedence over `hide_history`.
```kotlin label="Kotlin"
val cutoff = Date()
cutoff.time -= 7.days.inWholeMilliseconds
channelClient
.addMembers(memberIds = listOf("thierry"), hideHistoryBefore = cutoff)
.enqueue()
```
```js label="JavaScript"
const cutoff = new Date();
cutoff.setDate(date.getDate() - 7); // Last 7 days
await channel.addMembers(["thierry"], undefined, {
hide_history_before: cutoff.toISOString(),
});
```
```go label="Go"
t := time.Now().Add(-7 * 24 * time.Hour)
cutoff := getstream.Timestamp{Time: &t}
channel.Update(ctx, &getstream.UpdateChannelRequest{
AddMembers: []getstream.ChannelMemberRequest{{UserID: "thierry"}},
HideHistoryBefore: &cutoff,
})
```
```python label="Python"
from datetime import datetime, timedelta, timezone
from getstream.models import ChannelMemberRequest
cutoff = datetime.now(timezone.utc) - timedelta(days=7) # Last 7 days
channel.update(
add_members=[ChannelMemberRequest(user_id="thierry")],
hide_history_before=cutoff,
)
```
```php label="PHP"
use GetStream\ChatClient;
use GetStream\GeneratedModels as Models;
$client->updateChannel("messaging", "channel-id", new Models\UpdateChannelRequest(
addMembers: [new Models\ChannelMemberRequest(userID: "thierry")],
hideHistoryBefore: new \DateTime("-7 days"),
));
```
```csharp label="C#"
var cutoff = DateTime.UtcNow.AddDays(-7); // Last 7 days
await chat.UpdateChannelAsync("messaging", channelId,
new UpdateChannelRequest
{
AddMembers = new List
{
new ChannelMemberRequest { UserID = "thierry" }
},
HideHistoryBefore = cutoff
});
```
```ruby label="Ruby"
require 'getstream_ruby'
Models = GetStream::Generated::Models
cutoff = (DateTime.now - 7).iso8601 # Last 7 days
client.chat.update_channel("messaging", "channel-id", Models::UpdateChannelRequest.new(
add_members: [
Models::ChannelMemberRequest.new(user_id: "thierry"),
],
hide_history_before: cutoff,
))
```
```java label="Java"
// Backend SDK
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DAY_OF_MONTH, -7);
Date cutoff = calendar.getTime();
chat.updateChannel("channel-type", "channel-id", UpdateChannelRequest.builder()
.addMembers(List.of(ChannelMemberRequest.builder().userID("thierry").build()))
.hideHistoryBefore(cutoff)
.build()).execute();
```
```swift label="Swift"
// Controllers
let cutoff = Calendar.current.date(byAdding: .day, value: -7, to: Date())
channelController.addMembers(
userIds: ["thierry"],
hideHistoryBefore: cutoff
) { error in
// …
}
// State layer (async-await)
let cutoff = Calendar.current.date(byAdding: .day, value: -7, to: Date())
try await chat.addMembers(["thierry"], hideHistoryBefore: cutoff)
```
```dart label="Dart"
final cutoff = DateTime.now().subtract(Duration(days: 7)); // Last 7 days
await channel.addMembers(
["thierry"],
hideHistoryBefore: cutoff,
);
```
## System Message Parameter
You can optionally include a message object when adding or removing members that client-side SDKs will use to display a system message. This works for both adding and removing members.
```kotlin label="Kotlin"
val channelClient = client.channel("messaging", "general")
// Add members with a system message
channelClient.addMembers(
listOf("thierry", "josh"),
Message(text = "Thierry and Josh joined this channel."),
).enqueue()
// Add members with custom extra data and a system message
val params = AddMembersParams(
members = listOf(
MemberData(userId = "thierry", extraData = mapOf("new_member" to true)),
MemberData(userId = "josh", extraData = mapOf("new_member" to true)),
),
systemMessage = Message(text = "Thierry and Josh joined this channel."),
)
channelClient.addMembers(params).enqueue()
// Remove member with a system message
channelClient.removeMembers(
listOf("tommaso"),
Message(text = "Tommaso was removed from this channel."),
).enqueue()
```
```js label="JavaScript"
// Using client-side client
await channel.addMembers(["tommaso"], { text: "Tommaso joined the channel." });
// Using server-side client, you need to specify the sender user_id
await channel.addMembers(["tommaso"], {
text: "Tommaso joined the channel.",
user_id: "tommaso",
});
```
```go label="Go"
channel.Update(ctx, &getstream.UpdateChannelRequest{
AddMembers: []getstream.ChannelMemberRequest{{UserID: "tommaso"}},
Message: &getstream.MessageRequest{
Text: getstream.PtrTo("Tommaso joined the channel."),
UserID: getstream.PtrTo("tommaso"),
},
})
```
```python label="Python"
from getstream.models import ChannelMemberRequest, MessageRequest
channel.update(
add_members=[
ChannelMemberRequest(user_id="tommaso"),
ChannelMemberRequest(user_id="josh"),
],
message=MessageRequest(
text="Tommaso joined the channel.",
user_id="tommaso",
),
)
```
```php label="PHP"
use GetStream\ChatClient;
use GetStream\GeneratedModels as Models;
$client->updateChannel("messaging", "channel-id", new Models\UpdateChannelRequest(
addMembers: [new Models\ChannelMemberRequest(userID: "tommaso")],
message: new Models\MessageRequest(
text: "Tommaso joined the channel.",
userID: "tommaso",
),
));
```
```csharp label="C#"
await chat.UpdateChannelAsync("messaging", channelId,
new UpdateChannelRequest
{
AddMembers = new List
{
new ChannelMemberRequest { UserID = "tommaso" }
},
Message = new MessageRequest
{
Text = "Tommaso joined the channel",
UserID = "tommaso"
}
});
```
```ruby label="Ruby"
require 'getstream_ruby'
Models = GetStream::Generated::Models
client.chat.update_channel("messaging", "channel-id", Models::UpdateChannelRequest.new(
add_members: [
Models::ChannelMemberRequest.new(user_id: "tommaso"),
Models::ChannelMemberRequest.new(user_id: "josh"),
],
message: Models::MessageRequest.new(
text: "Tommaso joined the channel.",
user_id: "tommaso",
),
))
```
```java label="Java"
// Android SDK
Message addMemberSystemMessage = new Message();
addMemberSystemMessage.setText("Thierry and Josh were added to this channel");
channelClient.addMembers(Arrays.asList("thierry", "josh"), addMemberSystemMessage).enqueue(result -> {
if (result.isSuccess()) {
Channel channel = result.data();
} else {
// Handle result.error()
}
});
// Backend SDK
chat.updateChannel("messaging", "general", UpdateChannelRequest.builder()
.addMembers(List.of(
ChannelMemberRequest.builder().userID("thierry").build(),
ChannelMemberRequest.builder().userID("josh").build()))
.message(MessageRequest.builder()
.text("Thierry and Josh were added to this channel")
.build())
.build()).execute();
```
```cpp label="Unreal"
Channel->AddMembers({TEXT("tommaso")}, FMessage{TEXT("Tommaso joined the channel.")});
```
```csharp label="Unity"
await channel.AddMembersAsync(users, hideHistory: default, new StreamMessageRequest
{
Text = "John has joined the channel"
});
```
```swift label="Swift"
// Controllers
channelController.addMembers(
userIds: ["tommaso"],
message: "Tommaso joined the channel"
) { error in
// …
}
// State layer (async-await)
try await chat.addMembers(["tommaso"], systemMessage: "Tommaso joined the channel")
```
## Adding and Removing Moderators
Using the `addModerators()` method adds the given users as moderators (or updates their role to moderator if already members), while `demoteModerators()` removes the moderator status.
### Add Moderators
```js label="JavaScript"
await channel.addModerators(["thierry", "josh"]);
```
```python label="Python"
channel.update(add_moderators=["thierry", "josh"])
```
```ruby label="Ruby"
require 'getstream_ruby'
Models = GetStream::Generated::Models
client.chat.update_channel("messaging", "channel-id", Models::UpdateChannelRequest.new(
add_moderators: ["thierry", "josh"],
))
```
```php label="PHP"
use GetStream\ChatClient;
use GetStream\GeneratedModels as Models;
$client->updateChannel("messaging", "channel-id", new Models\UpdateChannelRequest(
addModerators: ["thierry", "jenny"],
));
```
```java label="Java"
// Backend SDK
chat.updateChannel("channel-type", "channel-id", UpdateChannelRequest.builder()
.addModerators(List.of("thierry", "josh"))
.build()).execute();
```
```csharp label="C#"
await chat.UpdateChannelAsync("messaging", channelId,
new UpdateChannelRequest
{
AddModerators = new List { "thierry", "josh" }
});
```
```go label="Go"
channel.Update(ctx, &getstream.UpdateChannelRequest{
AddModerators: []string{"thierry", "josh"},
})
```
### Remove Moderators
```js label="JavaScript"
await channel.demoteModerators(["tommaso"]);
```
```python label="Python"
channel.update(demote_moderators=["tommaso"])
```
```ruby label="Ruby"
require 'getstream_ruby'
Models = GetStream::Generated::Models
client.chat.update_channel("messaging", "channel-id", Models::UpdateChannelRequest.new(
demote_moderators: ["tommaso"],
))
```
```php label="PHP"
use GetStream\ChatClient;
use GetStream\GeneratedModels as Models;
$client->updateChannel("messaging", "channel-id", new Models\UpdateChannelRequest(
demoteModerators: ["thierry", "jenny"],
));
```
```java label="Java"
// Backend SDK
chat.updateChannel("channel-type", "channel-id", UpdateChannelRequest.builder()
.demoteModerators(List.of("tommaso"))
.build()).execute();
```
```csharp label="C#"
await chat.UpdateChannelAsync("messaging", channelId,
new UpdateChannelRequest
{
DemoteModerators = new List { "tommaso" }
});
```
```go label="Go"
channel.Update(ctx, &getstream.UpdateChannelRequest{
DemoteModerators: []string{"tommaso"},
})
```
These operations can only be performed server-side, and a maximum of 100 moderators can be added or removed at once.
## Member Custom Data
Custom data can be added at the channel member level. This is useful for storing member-specific information that is separate from user-level data. Ensure custom data does not exceed 5KB.
### Adding Custom Data
```js label="JavaScript"
// Add custom data while creating the channel
const channel = client.channel("messaging", randomID, {
members: [
{ user_id: "userid1", key1: "value1" },
{ user_id: "userid2", key1: "value1" },
{ user_id: "userid3", key2: "value2" },
],
});
// Add custom data with addMembers method
await channel.addMembers([{ user_id: "userid1", key1: "value1" }]);
```
```swift label="Swift"
channelController.addMembers([
MemberInfo(userId: "userid1", extraData: ["key1": .string("value1")]),
MemberInfo(userId: "userid2", extraData: ["key2": .string("value2")]),
MemberInfo(userId: "userid3", extraData: ["key3": .string("value3")])
])
```
```kotlin label="Kotlin"
// Add custom data while creating the channel
val params = CreateChannelParams(
members = listOf(
MemberData(userId = "userid1", extraData = mapOf("key1" to "value1")),
MemberData(userId = "userid2", extraData = mapOf("key2" to "value2")),
MemberData(userId = "userid3", extraData = mapOf("key3" to "value3")),
),
extraData = emptyMap(),
)
channelClient.create(params).enqueue()
// Add custom data with addMembers method
val params = AddMembersParams(
members = listOf(
MemberData(userId = "userid1", extraData = mapOf("key1" to "value1")),
),
)
channelClient.addMembers(params).enqueue()
```
```csharp label="C#"
// Add a member first
await chat.UpdateChannelAsync("messaging", "my-channel-id",
new UpdateChannelRequest
{
AddMembers = new List
{
new ChannelMemberRequest { UserID = "user-2" }
}
});
// Set custom data on the member
await chat.UpdateMemberPartialAsync("messaging", "my-channel-id",
new UpdateMemberPartialRequest
{
Set = new Dictionary
{
["hat"] = "blue" // Channel member custom data is separate from user custom data
}
});
```
### Updating Member Data
Channel members can be partially updated. Only custom data and channel roles are eligible for modification. You can set or unset fields, either separately or in the same call.
```js label="JavaScript"
// Set some fields
await channel.updateMemberPartial(
{
set: {
key1: "new value 1",
key2: "new value 2",
channel_role: "channel_moderator",
},
},
{ userId: "jane" },
);
// Unset some fields
await channel.updateMemberPartial(
{
unset: ["key1", "key2"],
},
{ userId: "jane" },
);
// Set and unset in the same call
await channel.updateMemberPartial(
{
set: {
key1: "new value 1",
key2: "new value 2",
},
unset: ["key3"],
},
{ userId: "jane" },
);
```
```swift label="Swift"
// Set some fields
let memberController = ChatClient.shared.memberController(
userId: someUserId,
in: someChannelId
)
memberController.partialUpdate(extraData: [
"key1": .string("value1"),
"key2": .string("value2")
])
// Unset some fields
memberController.partialUpdate(extraData: nil, unsetProperties: ["key1", "key2"])
// Set and unset in the same call
memberController.partialUpdate(
extraData: [
"key1": .string("value1"),
"key2": .string("value2"),
],
unsetProperties: ["key3"]
)
```
```go label="Go"
channel := client.Chat().Channel("messaging", "general")
// Set some fields
channel.UpdateMemberPartial(ctx, &getstream.UpdateMemberPartialRequest{
UserID: getstream.PtrTo("userid1"),
Set: map[string]any{"color": "red"},
})
// Unset some fields
channel.UpdateMemberPartial(ctx, &getstream.UpdateMemberPartialRequest{
UserID: getstream.PtrTo("userid1"),
Unset: []string{"age"},
})
// Set and unset in the same call
channel.UpdateMemberPartial(ctx, &getstream.UpdateMemberPartialRequest{
UserID: getstream.PtrTo("userid1"),
Set: map[string]any{"color": "red"},
Unset: []string{"age"},
})
```
```php label="Php"
use GetStream\ChatClient;
use GetStream\GeneratedModels as Models;
// Set some fields
$client->updateMemberPartial("messaging", "channel-id", "amy", new Models\UpdateMemberPartialRequest(
set: (object)["hat" => "blue"],
));
// Unset some fields
$client->updateMemberPartial("messaging", "channel-id", "amy", new Models\UpdateMemberPartialRequest(
unset: ["hat"],
));
// Set and unset in the same call
$client->updateMemberPartial("messaging", "channel-id", "amy", new Models\UpdateMemberPartialRequest(
set: (object)["hat" => "blue"],
unset: ["hat"],
));
```
```python label="Python"
user_id = "amy"
# Set some fields
response = channel.update_member_partial(user_id=user_id, set={"hat": "blue"})
# Unset some fields
response = channel.update_member_partial(user_id=user_id, unset=["hat"])
# Set and unset in the same call
response = channel.update_member_partial(user_id=user_id, set={"color": "red"}, unset=["hat"])
```
```ruby label="Ruby"
require 'getstream_ruby'
Models = GetStream::Generated::Models
user_id = "amy"
# Set some fields
client.chat.update_member_partial("messaging", "channel-id", Models::UpdateMemberPartialRequest.new(
set: { 'color' => 'red' }
), user_id)
# Unset some fields
client.chat.update_member_partial("messaging", "channel-id", Models::UpdateMemberPartialRequest.new(
unset: ['hat']
), user_id)
# Set and unset in the same call
client.chat.update_member_partial("messaging", "channel-id", Models::UpdateMemberPartialRequest.new(
set: { 'color' => 'red' },
unset: ['hat']
), user_id)
```
```java label="Java"
// Set some fields
chat.updateMemberPartial(channel.getType(), channel.getId(), UpdateMemberPartialRequest.builder()
.UserID("user-1")
.set(Map.of("custom_key", "custom_value", "channel_role", "channel_moderator"))
.build()).execute();
// Unset some fields
chat.updateMemberPartial(channel.getType(), channel.getId(), UpdateMemberPartialRequest.builder()
.UserID("user-1")
.unset(List.of("custom_key"))
.build()).execute();
// Set and unset in the same call
chat.updateMemberPartial(channel.getType(), channel.getId(), UpdateMemberPartialRequest.builder()
.UserID("user-1")
.set(Map.of("color", "red"))
.unset(List.of("age"))
.build()).execute();
```
```csharp label="C#"
// Set some fields
// Note: user_id is passed as a query parameter
await client.MakeRequestAsync(
"PATCH",
"/api/v2/chat/channels/{type}/{id}/member",
new Dictionary { ["user_id"] = "user-2" },
new UpdateMemberPartialRequest
{
Set = new Dictionary
{
["hat"] = "blue",
["score"] = 1000
}
},
new Dictionary { ["type"] = "messaging", ["id"] = "my-channel-id" });
// Unset some fields
await client.MakeRequestAsync(
"PATCH",
"/api/v2/chat/channels/{type}/{id}/member",
new Dictionary { ["user_id"] = "user-2" },
new UpdateMemberPartialRequest
{
Unset = new List { "hat", "score" }
},
new Dictionary { ["type"] = "messaging", ["id"] = "my-channel-id" });
// Set and unset in a single request
await client.MakeRequestAsync(
"PATCH",
"/api/v2/chat/channels/{type}/{id}/member",
new Dictionary { ["user_id"] = "user-2" },
new UpdateMemberPartialRequest
{
Set = new Dictionary { ["hat"] = "blue" },
Unset = new List { "score" }
},
new Dictionary { ["type"] = "messaging", ["id"] = "my-channel-id" });
```
```kotlin label="Kotlin"
// Set some fields
channelClient.partialUpdateMember(
userId = "userid1",
set = mapOf(
"key1" to "new value 1",
"key2" to "new value 2",
),
).enqueue()
// Unset some fields
channelClient.partialUpdateMember(
userId = "userid1",
unset = listOf("key1", "key2"),
).enqueue()
// Set and unset in the same call
channelClient.partialUpdateMember(
userId = "userid1",
set = mapOf(
"key1" to "new value 1",
"key2" to "new value 2",
),
unset = listOf("key3"),
).enqueue()
```
---
This page was last updated at 2026-05-22T16:32:19.200Z.
For the most recent version of this documentation, visit [https://getstream.io/chat/docs/javascript/channel-members/](https://getstream.io/chat/docs/javascript/channel-members/).