Activity Feeds v3 is in beta — try it out!

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:

// 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
    )
)

// 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
    )
)

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

// 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,
  ),
);

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

_, 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)
}

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

$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'
            ),
        ]
    )
);

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

# 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"
        }
    ]
)

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

Overview of the feed member model

FeedMemberResponse

Name	Type	Description	Constraints
`created_at`	`number`	When the membership was created	Required
`custom`	`object`	Custom data for the membership	-
`invite_accepted_at`	`number`	When the invite was accepted	-
`invite_rejected_at`	`number`	When the invite was rejected	-
`membership_level`	`MembershipLevelResponse`	Membership level assigned to the member	-
`role`	`string`	Role of the member in the feed	Required
`status`	`string (member, pending, rejected)`	Status of the membership	Required
`updated_at`	`number`	When the membership was last updated	Required
`user`	`UserResponse`	User who is a member	Required

Feed members vs followers

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

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

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

// 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()

// 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()

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();

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

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

// 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)

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

$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'
    )
);

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

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

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

Query Feed Members

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

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
}

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

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

Membership levels

Intro & Defaults