# Members

## Manage members

You can add and remove members to a feed. This is useful for building communities where a set of users can add content to the feed.

It's not possible to set/update member role on client-side. Use server-side SDKs for this. When adding members client-side all new members will have `feed_member` role:

<Tabs>

```swift label="Swift"
// The following methods are available to edit the members of a feed
try await feed.updateFeedMembers(
    request: .init(
        members: [.init(
            custom: ["joined": "2024-01-01"],
            userId: "john"
        )],
        operation: .upsert
    )
)
// Remove members
try await feed.updateFeedMembers(
    request: .init(
        members: [.init(userId: "john"), .init(userId: "jane")],
        operation: .remove
    )
)
// Set members (overwrites the list)
try await feed.updateFeedMembers(
    request: .init(
        members: [.init(userId: "john")],
        operation: .set
    )
)
```

```kotlin label="Kotlin"
// The following methods are available to edit the members of a feed
feed.updateFeedMembers(
    request = UpdateFeedMembersRequest(
        members = listOf(
            FeedMemberRequest(
                custom = mapOf("joined" to "2024-01-01"),
                userId = "john"
            )
        ),
        operation = UpdateFeedMembersRequest.Operation.Upsert
    )
)
// Remove members
feed.updateFeedMembers(
    request = UpdateFeedMembersRequest(
        members = listOf(
            FeedMemberRequest(userId = "john"),
            FeedMemberRequest(userId = "jane")
        ),
        operation = UpdateFeedMembersRequest.Operation.Remove
    )
)
// Set members (overwrites the list)
feed.updateFeedMembers(
    request = UpdateFeedMembersRequest(
        members = listOf(
            FeedMemberRequest(userId = "john")
        ),
        operation = UpdateFeedMembersRequest.Operation.Set
    )
)
```

```js label="JavaScript"
// The following methods are available to add or edit the members of a feed
await feed.updateFeedMembers({
  operation: "upsert",
  members: [
    {
      user_id: "john",
      custom: {
        joined: "2024-01-01",
      },
    },
  ],
});

// Remove members
await feed.updateFeedMembers({
  operation: "remove",
  members: [
    {
      user_id: "john",
    },
    {
      user_id: "jane",
    },
  ],
});

// Set members (overwrites the list)
await feed.updateFeedMembers({
  operation: "set",
  members: [
    {
      user_id: "john",
    },
  ],
});
```

```js label="React"
// The following methods are available to add or edit the members of a feed
await feed.updateFeedMembers({
  operation: "upsert",
  members: [
    {
      user_id: "john",
      custom: {
        joined: "2024-01-01",
      },
    },
  ],
});

// Remove members
await feed.updateFeedMembers({
  operation: "remove",
  members: [
    {
      user_id: "john",
    },
    {
      user_id: "jane",
    },
  ],
});

// Set members (overwrites the list)
await feed.updateFeedMembers({
  operation: "set",
  members: [
    {
      user_id: "john",
    },
  ],
});
```

```js label="React Native"
// The following methods are available to add or edit the members of a feed
await feed.updateFeedMembers({
  operation: "upsert",
  members: [
    {
      user_id: "john",
      custom: {
        joined: "2024-01-01",
      },
    },
  ],
});

// Remove members
await feed.updateFeedMembers({
  operation: "remove",
  members: [
    {
      user_id: "john",
    },
    {
      user_id: "jane",
    },
  ],
});

// Set members (overwrites the list)
await feed.updateFeedMembers({
  operation: "set",
  members: [
    {
      user_id: "john",
    },
  ],
});
```

```dart label="Dart"
// The following methods are available to edit the members of a feed
final result = await feed.updateFeedMembers(
  request: const UpdateFeedMembersRequest(
    members: [
      FeedMemberRequest(
        custom: {'joined': '2024-01-01'},
        userId: 'john',
      ),
    ],
    operation: UpdateFeedMembersRequestOperation.upsert,
  ),
);

// Remove members
await feed.updateFeedMembers(
  request: const UpdateFeedMembersRequest(
    members: [
      FeedMemberRequest(userId: 'john'),
      FeedMemberRequest(userId: 'jane'),
    ],
    operation: UpdateFeedMembersRequestOperation.remove,
  ),
);

// Set members (overwrites the list)
await feed.updateFeedMembers(
  request: const UpdateFeedMembersRequest(
    members: [FeedMemberRequest(userId: 'john')],
    operation: UpdateFeedMembersRequestOperation.set,
  ),
);
```

```js label="Node"
// The following methods are available to add or edit the members of a feed
await feed.updateFeedMembers({
  operation: "upsert",
  members: [
    {
      user_id: "john",
      role: "feed_moderator",
      custom: {
        joined: "2024-01-01",
      },
    },
  ],
});

// Remove members
await feed.updateFeedMembers({
  operation: "remove",
  members: [
    {
      user_id: "john",
    },
    {
      user_id: "jane",
    },
  ],
});

// Set members (overwrites the list)
await feed.updateFeedMembers({
  operation: "set",
  members: [
    {
      user_id: "john",
      role: "feed_moderator",
    },
  ],
});
```

```go label="Go"
_, err = feed.UpdateFeedMembers(context.Background(), &getstream.UpdateFeedMembersRequest{
	Operation: "upsert",
	Members: []getstream.FeedMemberRequest{
		{
			UserID: "john",
			Role:   getstream.PtrTo("feed_moderator"),
			Custom: map[string]any{
				"joined": "2024-01-01",
			},
		},
	},
})
if err != nil {
	log.Fatal(err)
}

// Remove members
_, err = feed.UpdateFeedMembers(context.Background(), &getstream.UpdateFeedMembersRequest{
	Operation: "remove",
	Members: []getstream.FeedMemberRequest{
		{
			UserID: "john",
		},
		{
			UserID: "jane",
		},
	},
})
if err != nil {
	log.Fatal(err)
}

// Set members (overwrites the list)
_, err = feed.UpdateFeedMembers(context.Background(), &getstream.UpdateFeedMembersRequest{
	Operation: "set",
	Members: []getstream.FeedMemberRequest{
		{
			UserID: "john",
			Role:   getstream.PtrTo("feed_moderator"),
		},
	},
})
if err != nil {
	log.Fatal(err)
}
```

```java label="Java"
// The following methods are available to edit the members of a feed
UpdateFeedMembersRequest upsertRequest = UpdateFeedMembersRequest.builder()
    .operation("upsert")
    .members(List.of(
        FeedMemberRequest.builder()
            .userID("john")
            .role("feed_moderator")
            .custom(Map.of("joined", "2024-01-01"))
            .build()
    ))
    .build();

feeds.updateFeedMembers("user", "community_id", upsertRequest).execute();

// Remove members
UpdateFeedMembersRequest removeRequest = UpdateFeedMembersRequest.builder()
    .operation("remove")
    .members(List.of(
        FeedMemberRequest.builder().userID("john").build(),
        FeedMemberRequest.builder().userID("jane").build()
    ))
    .build();

feeds.updateFeedMembers("user", "community_id", removeRequest).execute();

// Set members (overwrites the list)
UpdateFeedMembersRequest setRequest = UpdateFeedMembersRequest.builder()
    .operation("set")
    .members(List.of(
        FeedMemberRequest.builder()
            .userID("john")
            .role("feed_moderator")
            .build()
    ))
    .build();

feeds.updateFeedMembers("user", "community_id", setRequest).execute();
```

```php label="php"
$feed = $feedsClient->feed('user', 'community_id');

// The following methods are available to edit the members of a feed
$feed->updateFeedMembers(
    new GeneratedModels\UpdateFeedMembersRequest(
        operation: 'upsert',
        members: [
            new GeneratedModels\FeedMemberRequest(
                userID: 'john',
                role: 'feed_moderator',
                custom: (object)['joined' => '2024-01-01']
            ),
        ]
    )
);

// Remove members
$feed->updateFeedMembers(
    new GeneratedModels\UpdateFeedMembersRequest(
        operation: 'remove',
        members: [
            new GeneratedModels\FeedMemberRequest(userID: 'john'),
            new GeneratedModels\FeedMemberRequest(userID: 'jane'),
        ]
    )
);

// Set members (overwrites the list)
$feed->updateFeedMembers(
    new GeneratedModels\UpdateFeedMembersRequest(
        operation: 'set',
        members: [
            new GeneratedModels\FeedMemberRequest(
                userID: 'john',
                role: 'feed_moderator'
            ),
        ]
    )
);
```

```csharp label="C#"
// The following methods are available to edit the members of a feed
await _feedsV3Client.UpdateFeedMembersAsync(
    FeedGroupID: "user",
    FeedID: "community_id",
    request: new UpdateFeedMembersRequest
    {
        Operation = "upsert",
        Members = new List<FeedMemberRequest>
        {
            new FeedMemberRequest
            {
                UserID = "john",
                Role = "feed_moderator",
                Custom = new { joined = "2024-01-01" }
            }
        }
    }
);

// Remove members
await _feedsV3Client.UpdateFeedMembersAsync(
    FeedGroupID: "user",
    FeedID: "community_id",
    request: new UpdateFeedMembersRequest
    {
        Operation = "remove",
        Members = new List<FeedMemberRequest>
        {
            new FeedMemberRequest { UserID = "john" },
            new FeedMemberRequest { UserID = "jane" }
        }
    }
);

// Set members (overwrites the list)
await _feedsV3Client.UpdateFeedMembersAsync(
    FeedGroupID: "user",
    FeedID: "community_id",
    request: new UpdateFeedMembersRequest
    {
        Operation = "set",
        Members = new List<FeedMemberRequest>
        {
            new FeedMemberRequest
            {
                UserID = "john",
                Role = "feed_moderator"
            }
        }
    }
);
```

```python label="Python"
# The following methods are available to edit the members of a feed
feeds.update_feed_members(
    feed_group="user",
    feed_id="community_id",
    operation="upsert",
    members=[
        {
            "user_id": "john",
            "role": "feed_moderator",
            "custom": {"joined": "2024-01-01"}
        }
    ]
)

# Remove members
feeds.update_feed_members(
    feed_group="user",
    feed_id="community_id",
    operation="remove",
    members=[
        {"user_id": "john"},
        {"user_id": "jane"}
    ]
)

# Set members (overwrites the list)
feeds.update_feed_members(
    feed_group="user",
    feed_id="community_id",
    operation="set",
    members=[
        {
            "user_id": "john",
            "role": "feed_moderator"
        }
    ]
)
```

```ruby label="Ruby"
# The following methods are available to edit the members of a feed
client.feeds.update_feed_members(
  "user",
  "community_id",
  GetStream::Generated::Models::UpdateFeedMembersRequest.new(
    operation: "upsert",
    members: [
      GetStream::Generated::Models::FeedMemberRequest.new(
        user_id: "john",
        role: "feed_moderator",
        custom: { "joined" => "2024-01-01" }
      )
    ]
  )
)

# Remove members
client.feeds.update_feed_members(
  "user",
  "community_id",
  GetStream::Generated::Models::UpdateFeedMembersRequest.new(
    operation: "remove",
    members: [
      GetStream::Generated::Models::FeedMemberRequest.new(user_id: "john"),
      GetStream::Generated::Models::FeedMemberRequest.new(user_id: "jane")
    ]
  )
)

# Set members (overwrites the list)
client.feeds.update_feed_members(
  "user",
  "community_id",
  GetStream::Generated::Models::UpdateFeedMembersRequest.new(
    operation: "set",
    members: [
      GetStream::Generated::Models::FeedMemberRequest.new(
        user_id: "john",
        role: "feed_moderator"
      )
    ]
  )
)
```

</Tabs>

## Overview of the feed member model

<open-api-models modelname="FeedMemberResponse" recursive="false" headerlevel="3">
</open-api-models>

## Feed members vs followers

Followers and members might seem like similar concepts, but they serve two different purposes with some key differences.

<b>Followers</b> can only be feeds (for example the `timeline` feed of Alice follows the `user` feed of Bob). Followers' aim is to access the content of a feed they're interested in and interact with it.

<b>Members</b> can only be users (for example Alice adds Bob as a member to her feed about "Travel Hacks"). The aim of feed members is usually to help out with admin tasks (helpful if you want to build apps similar to Facebook pages) or to decide what activities a user has access to using membership levels (for example Bob becomes a premium member in Alice's community).

## Member invites

You can invite members with the `invite` flag, where invited users can accept or reject the membership.

<Tabs>

```swift label="Swift"
// Request to become a member
try await feed.updateFeedMembers(
    request: .init(
        members: [.init(
            custom: ["reason": "community builder"],
            invite: true,
            userId: "john"
        )],
        operation: .upsert
    )
)
// Accept and reject member requests
_ = try await feed.acceptFeedMember()
_ = try await feed.rejectFeedMember()
```

```kotlin label="Kotlin"
// Request to become a member
feed.updateFeedMembers(
    request = UpdateFeedMembersRequest(
        members = listOf(
            FeedMemberRequest(
                custom = mapOf("reason" to "community builder"),
                invite = true,
                userId = "john"
            )
        ),
        operation = UpdateFeedMembersRequest.Operation.Upsert
    )
)
// Accept and reject member requests
feed.acceptFeedMember()
feed.rejectFeedMember()
```

```js label="JavaScript"
await invitingFeed.updateFeedMembers({
  operation: "upsert",
  members: [
    {
      user_id: "john",
      invite: true,
      custom: {
        reason: "community builder",
      },
    },
  ],
});

const feed = johnClient.feed(invitingFeed.group, invitingFeed.id);
// Then John can accept or reject
await feed.acceptFeedMemberInvite();

await feed.rejectFeedMemberInvite();
```

```js label="React"
await invitingFeed.updateFeedMembers({
  operation: "upsert",
  members: [
    {
      user_id: "john",
      invite: true,
      custom: {
        reason: "community builder",
      },
    },
  ],
});

const feed = johnClient.feed(invitingFeed.group, invitingFeed.id);
// Then John can accept or reject
await feed.acceptFeedMemberInvite();

await feed.rejectFeedMemberInvite();
```

```js label="React Native"
await invitingFeed.updateFeedMembers({
  operation: "upsert",
  members: [
    {
      user_id: "john",
      invite: true,
      custom: {
        reason: "community builder",
      },
    },
  ],
});

const feed = johnClient.feed(invitingFeed.group, invitingFeed.id);
// Then John can accept or reject
await feed.acceptFeedMemberInvite();

await feed.rejectFeedMemberInvite();
```

```dart label="Dart"
// Request to become a member
await feed.updateFeedMembers(
  request: const UpdateFeedMembersRequest(
    members: [
      FeedMemberRequest(
        custom: {'reason': 'community builder'},
        invite: true,
        userId: 'john',
      ),
    ],
    operation: UpdateFeedMembersRequestOperation.upsert,
  ),
);

// Accept and reject member requests
await feed.acceptFeedMember();
await feed.rejectFeedMember();
```

```js label="Node"
await feed.updateFeedMembers({
  operation: "upsert",
  members: [
    {
      user_id: "john",
      role: "feed_moderator",
      invite: true,
      custom: {
        reason: "community builder",
      },
    },
  ],
});

await feed.acceptFeedMemberInvite({
  user_id: "john",
});

await feed.rejectFeedMemberInvite({
  user_id: "john",
});
```

```go label="Go"
// Create feed
feed := client.Feeds().Feed("user", "alice")

// Update feed members with upsert operation
updateResponse, err := feed.UpdateFeedMembers(context.Background(), &getstream.UpdateFeedMembersRequest{
  Operation: "upsert",
  Members: []getstream.FeedMemberRequest{
    {
      UserID: "john",
      Role:   getstream.PtrTo("feed_moderator"),
      Invite: getstream.PtrTo(true),
      Custom: map[string]any{
        "reason": "community builder",
      },
    },
  },
})
if err != nil {
  log.Fatal("Error updating feed members:", err)
}
log.Printf("Feed members updated: %+v", updateResponse)

// Accept feed member invite
acceptResponse, err := feed.AcceptFeedMemberInvite(context.Background(), &getstream.AcceptFeedMemberInviteRequest{
  UserID: getstream.PtrTo("john"),
})
if err != nil {
  log.Fatal("Error accepting feed member invite:", err)
}
log.Printf("Feed member invite accepted: %+v", acceptResponse)

// Reject feed member invite
rejectResponse, err := feed.RejectFeedMemberInvite(context.Background(), &getstream.RejectFeedMemberInviteRequest{
  UserID: getstream.PtrTo("john"),
})
if err != nil {
  log.Fatal("Error rejecting feed member invite:", err)
}
log.Printf("Feed member invite rejected: %+v", rejectResponse)
```

```java label="Java"
// Invite a member
UpdateFeedMembersRequest inviteRequest = UpdateFeedMembersRequest.builder()
    .operation("upsert")
    .members(List.of(
        FeedMemberRequest.builder()
            .userID("john")
            .role("feed_moderator")
            .invite(true)
            .custom(Map.of("reason", "community builder"))
            .build()
    ))
    .build();

feeds.updateFeedMembers("user", "alice", inviteRequest).execute();

// Accept feed member invite
AcceptFeedMemberInviteRequest acceptRequest = AcceptFeedMemberInviteRequest.builder()
    .userID("john")
    .build();

feeds.acceptFeedMemberInvite("user", "alice", acceptRequest).execute();

// Reject feed member invite
RejectFeedMemberInviteRequest rejectRequest = RejectFeedMemberInviteRequest.builder()
    .userID("john")
    .build();

feeds.rejectFeedMemberInvite("user", "alice", rejectRequest).execute();
```

```php label="php"
$feed = $feedsClient->feed('user', 'alice');

// Invite a member
$feed->updateFeedMembers(
    new GeneratedModels\UpdateFeedMembersRequest(
        operation: 'upsert',
        members: [
            new GeneratedModels\FeedMemberRequest(
                userID: 'john',
                role: 'feed_moderator',
                invite: true,
                custom: (object)['reason' => 'community builder']
            ),
        ]
    )
);

// Accept feed member invite
$feed->acceptFeedMemberInvite(
    new GeneratedModels\AcceptFeedMemberInviteRequest(
        userID: 'john'
    )
);

// Reject feed member invite
$feed->rejectFeedMemberInvite(
    new GeneratedModels\RejectFeedMemberInviteRequest(
        userID: 'john'
    )
);
```

```csharp label="C#"
// Invite a member
await _feedsV3Client.UpdateFeedMembersAsync(
    FeedGroupID: "user",
    FeedID: "alice",
    request: new UpdateFeedMembersRequest
    {
        Operation = "upsert",
        Members = new List<FeedMemberRequest>
        {
            new FeedMemberRequest
            {
                UserID = "john",
                Role = "feed_moderator",
                Invite = true,
                Custom = new { reason = "community builder" }
            }
        }
    }
);

// Accept feed member invite
await _feedsV3Client.AcceptFeedMemberInviteAsync(
    FeedGroupID: "user",
    FeedID: "alice",
    request: new AcceptFeedMemberInviteRequest { UserID = "john" }
);

// Reject feed member invite
await _feedsV3Client.RejectFeedMemberInviteAsync(
    FeedGroupID: "user",
    FeedID: "alice",
    request: new RejectFeedMemberInviteRequest { UserID = "john" }
);
```

```python label="Python"
# Invite a member
feeds.update_feed_members(
    feed_group="user",
    feed_id="alice",
    operation="upsert",
    members=[
        {
            "user_id": "john",
            "role": "feed_moderator",
            "invite": True,
            "custom": {"reason": "community builder"}
        }
    ]
)

# Accept feed member invite
feeds.accept_feed_member_invite(
    feed_group="user",
    feed_id="alice",
    user_id="john"
)

# Reject feed member invite
feeds.reject_feed_member_invite(
    feed_group="user",
    feed_id="alice",
    user_id="john"
)
```

```ruby label="Ruby"
# Invite a member
client.feeds.update_feed_members(
  "user",
  "alice",
  GetStream::Generated::Models::UpdateFeedMembersRequest.new(
    operation: "upsert",
    members: [
      GetStream::Generated::Models::FeedMemberRequest.new(
        user_id: "john",
        role: "feed_moderator",
        invite: true,
        custom: { "reason" => "community builder" }
      )
    ]
  )
)

# Accept feed member invite
client.feeds.accept_feed_member_invite(
  "user",
  "alice",
  GetStream::Generated::Models::AcceptFeedMemberInviteRequest.new(user_id: "john")
)

# Reject feed member invite
client.feeds.reject_feed_member_invite(
  "user",
  "alice",
  GetStream::Generated::Models::RejectFeedMemberInviteRequest.new(user_id: "john")
)
```

</Tabs>

## Query Feed Members

You can query the members of a feed. This is useful for showing the list of members in a community.

<Tabs>

```kotlin label="Kotlin"
val memberList = client.memberList(
    MembersQuery(
        fid = FeedId(group = "stock", id = "apple"),
        filter = MembersFilterField.role.equal("moderator"),
    )
)
memberList.get()
memberList.state.members.collect { members ->
    // Handle members
}
```

```php label="php"
$response = $feedsClient->queryFeedMembers('stock', 'apple', new GeneratedModels\QueryFeedMembersRequest(
  filter: (object)[
    'role' => 'moderator'
  ]
));
```

```js label="JavaScript"
await feed.queryFeedMembers({
  filter: {
    role: "moderator",
  },
});
```

```js label="React"
await feed.queryFeedMembers({
  filter: {
    role: "moderator",
  },
});
```

```js label="React Native"
await feed.queryFeedMembers({
  filter: {
    role: "moderator",
  },
});
```

```js label="Node"
await feed.queryFeedMembers({
  filter: {
    role: "moderator",
  },
});
```

</Tabs>

## Feed Members Queryable Built-in Fields

| name         | type                                              | description                                    | supported operations                | example                                                    |
| ------------ | ------------------------------------------------- | ---------------------------------------------- | ----------------------------------- | ---------------------------------------------------------- |
| `user_id`    | string or list of strings                         | The ID of the user who is a member of the feed | `$in`, `$eq`                        | `{ user_id: { $eq: 'user_123' } }`                         |
| `role`       | string or list of strings                         | The role of the member                         | `$in`, `$eq`                        | `{ role: { $in: [ 'admin', 'moderator', 'member' ] } }`    |
| `status`     | string or list of strings                         | The membership status                          | `$in`, `$eq`                        | `{ status: { $in: [ 'member', 'pending', 'rejected' ] } }` |
| `created_at` | string, must be formatted as an RFC3339 timestamp | The time the membership was created            | `$eq`, `$gt`, `$gte`, `$lt`, `$lte` | `{ created_at: { $gte: '2023-12-04T09:30:20.45Z' } }`      |
| `updated_at` | string, must be formatted as an RFC3339 timestamp | The time the membership was last updated       | `$eq`, `$gt`, `$gte`, `$lt`, `$lte` | `{ updated_at: { $gte: '2023-12-04T09:30:20.45Z' } }`      |


---

This page was last updated at 2026-05-17T10:18:15.188Z.

For the most recent version of this documentation, visit [https://getstream.io/activity-feeds/docs/javascript/feed-members/](https://getstream.io/activity-feeds/docs/javascript/feed-members/).