Activity Feeds v3 is in beta — try it out!

Follow and Unfollow

Follow & Unfollow

The source feed should have a group that has “following” activity selector enabled, for example the built-in timeline group. The target feed should have a group that has “current” activity selector enabled, for example the built-in user group.

// Follow a user
let timeline = client.feed(group: "timeline", id: "john")
_ = try await timeline.follow(FeedId(group: "user", id: "tom"))

// Follow a stock
_ = try await timeline.follow(FeedId(group: "stock", id: "apple"))

// Follow with more fields
_ = try await timeline.follow(
    FeedId(group: "stock", id: "apple"),
    custom: ["reason": "investment"]
)

// Follow a user
val timeline = client.feed(group = "timeline", id = "john")
timeline.follow(FeedId(group = "user", id = "tom"))

// Follow a stock
timeline.follow(FeedId(group = "stock", id = "apple"))

// Follow with more fields
timeline.follow(
    targetFid = FeedId(group = "stock", id = "apple"),
    custom = mapOf("reason" to "investment")
)

const timeline = client.feed("timeline", "john");
await timeline.getOrCreate();

// Follow a user
await timeline.follow("user:tom");

// Follow a stock
await timeline.follow("stock:apple");

// Follow with more fields
await timeline.follow("stock:apple", {
  push_preference: "all",
  custom: {
    reason: "investment",
  },
});

// Follow a user
final timeline = client.feed(group: 'timeline', id: 'john');
await timeline.follow(targetFid: const FeedId(group: 'user', id: 'tom'));
// Follow a stock
await timeline.follow(targetFid: const FeedId(group: 'stock', id: 'apple'));
// Follow with more fields
await timeline.follow(
  targetFid: const FeedId(group: 'stock', id: 'apple'),
  custom: {'reason': 'investment'},
);

const timeline = client.feeds.feed("timeline", "john");
await timeline.getOrCreate({
  user_id: "john",
});

// Follow a user
await client.feeds.follow({
  source: timeline.feed,
  target: "user:tom",
});

// Follow a stock
await client.feeds.follow({
  source: timeline.feed,
  target: "stock:apple",
});

// Follow with more fields
await client.feeds.follow({
  source: timeline.feed,
  target: "stock:apple",
  push_preference: "all",
  custom: {
    reason: "investment",
  },
});

// Create timeline feed
timeline := client.Feeds().Feed("timeline", "john")
  _, err = timeline.GetOrCreate(context.Background(), &getstream.GetOrCreateFeedRequest{
  UserID: getstream.PtrTo("john"),
})
if err != nil {
  log.Fatal("Error getting/creating timeline feed:", err)
}
log.Println("Timeline feed created/retrieved successfully")

// Follow a user
_, err = client.Feeds().Follow(context.Background(), &getstream.FollowRequest{
  Source: "timeline:john",
  Target: "user:tom",
})
if err != nil {
  log.Fatal("Error following user:", err)
}
log.Println("Successfully followed user:tom")

// Follow a stock
_, err = client.Feeds().Follow(context.Background(), &getstream.FollowRequest{
  Source: "timeline:john",
  Target: "stock:apple",
})
if err != nil {
  log.Fatal("Error following stock:", err)
}
log.Println("Successfully followed stock:apple")

// Follow with more fields
_, err = client.Feeds().Follow(context.Background(), &getstream.FollowRequest{
  Source:         "timeline:john",
  Target:         "stock:apple",
  PushPreference: getstream.PtrTo("all"),
  Custom: map[string]any{
    "reason": "investment",
  },
})
if err != nil {
  log.Fatal("Error following stock with custom fields:", err)
}
log.Println("Successfully followed stock:apple with custom fields")

// Follow a user
FollowRequest followRequest =
    FollowRequest.builder()
        .source(USER_FEED_TYPE + testUserId)
        .target(USER_FEED_TYPE + testUserId2)
        .build();

SingleFollowResponse response = feeds.follow(followRequest).execute().getData();

// Unfollow
UnfollowRequest unfollowRequest = UnfollowRequest.builder().build();
UnfollowResponse unfollowResponse =
    feeds
        .unfollow(USER_FEED_TYPE + testUserId, USER_FEED_TYPE + testUserId2, unfollowRequest)
        .execute()
        .getData();

// Follow a user
$timeline = $feedsClient->feed('timeline', 'john');
$timeline->getOrCreateFeed(
    new GeneratedModels\GetOrCreateFeedRequest(userID: 'john')
);

$response = $feedsClient->follow(
    new GeneratedModels\FollowRequest(
        source: 'timeline:john',
        target: 'user:tom'
    )
);

// Follow a stock
$response = $feedsClient->follow(
    new GeneratedModels\FollowRequest(
        source: 'timeline:john',
        target: 'stock:apple'
    )
);

// Follow with more fields
$response = $feedsClient->follow(
    new GeneratedModels\FollowRequest(
        source: 'timeline:john',
        target: 'stock:apple',
        pushPreference: 'all',
        custom: (object)['reason' => 'investment']
    )
);

// Unfollow
$response = $feedsClient->unfollow('timeline:john', 'user:tom');

// Follow a user
var response = await _feedsV3Client.FollowAsync(
    new FollowRequest
    {
        Source = $"user:{_testFeedId}",
        Target = $"user:{_testFeedId2}"
    }
);

// Unfollow
var unfollowResponse = await _feedsV3Client.UnfollowAsync(
    $"user:{_testFeedId}",
    $"user:{_testFeedId3}",
    new { user_id = _testUserId }
);

# Follow a user
response = self.client.feeds.follow(
    source=f"{self.USER_FEED_TYPE}:{self.test_user_id}",
    target=f"{self.USER_FEED_TYPE}:{self.test_user_id_2}",
)

# Unfollow
unfollow_response = self.client.feeds.unfollow(
    f"{self.USER_FEED_TYPE}:{self.test_user_id}",
    f"{self.USER_FEED_TYPE}:{self.test_user_id_2}",
)

# Follow a user
follow_request = {
  source: 'user:user123',
  target: 'user:user456'
}

follow_response = client.feeds.follow(follow_request)

# Unfollow a user
unfollow_response = client.feeds.unfollow(
  'user:user123',
  'user:user456'
)

Trying to follow a feed that is already followed will result in an error. Similarly, trying to unfollow a feed that is not followed, will result in an error.

When unfollowing a feed, all previous activities of that feed are removed from the timeline.

Querying Follows

// Do I follow a list of feeds
// My feed is timeline:john
let followQuery = FollowsQuery(
    filter: .and([
        .equal(.sourceFeed, "timeline:john"),
        .in(.targetFeed, ["user:sara", "user:adam"])
    ])
)
let followList = client.followList(for: followQuery)
let page1 = try await followList.get()
let page2 = try await followList.queryMoreFollows()
let page1And2 = followList.state.follows

// Paginating through followers for a feed
// My feed is timeline:john
let followerQuery = FollowsQuery(
    filter: .equal(.targetFeed, "timeline:john")
)
let followerList = client.followList(for: followerQuery)
let followerPage1 = try await followerList.get()

// Do I follow a list of feeds
// My feed is timeline:john
val followQuery = FollowsQuery(
    filter = Filters.and(
        FollowsFilterField.sourceFeed.equal("timeline:john"),
        FollowsFilterField.targetFeed.`in`("user:sara", "user:adam")
    )
)
val followList = client.followList(query = followQuery)
val page1: Result<List<FollowData>> = followList.get()
val page2: Result<List<FollowData>> = followList.queryMoreFollows()
val page1And2 = followList.state.follows

// Paginating through followers for a feed
// My feed is timeline:john
val followerQuery = FollowsQuery(
    filter = FollowsFilterField.targetFeed.equal("timeline:john")
)
val followerList = client.followList(query = followerQuery)
val followerPage1: Result<List<FollowData>> = followerList.get()

const myTimeline = client.feed("timeline", "john");
await myTimeline.getOrCreate();

// Do I follow a list of feeds
const response = await client.queryFollows({
  filter: {
    source_feed: myTimeline.feed,
    target_feed: { $in: ["user:sara", "user:adam"] },
  },
});

console.log(response.follows);

const userFeed = client.feed("user", "john");
await userFeed.getOrCreate();

// Paginating through followers for a feed - won't store followers in state
const firstPage = await userFeed.queryFollowers({
  limit: 20,
});

// Next page - won't store followers in state
const secondPage = await userFeed.queryFollowers({
  limit: 20,
  next: firstPage.next,
});

// or load when reading feed - will store followers in state
await feed.getOrCreate({
  followers_pagination: {
    limit: 10,
  },
});

// and then load next pages (or first if followers are not yet loaded) - will store followers in state
await feed.loadNextPageFollowers({ limit: 10 });

console.log(feed.state.getLatestValue().followers);

// Filter by source - feeds that I follow - won't store followings in state
await myTimeline.queryFollowing({ limit: 10 });

// or load when reading feed - will store followings in state
await feed.getOrCreate({
  following_pagination: {
    limit: 10,
  },
});

// and then load next pages (or first if followings are not yet loaded) - will store followings in state
await feed.loadNextPageFollowing({ limit: 10 });

console.log(feed.state.getLatestValue().following);

// Do I follow a list of feeds
// My feed is timeline:john
const followQuery = FollowsQuery(
  filter: Filter.and([
    Filter.equal(FollowsFilterField.sourceFeed, 'timeline:john'),
    Filter.in_(FollowsFilterField.targetFeed, ['user:sara', 'user:adam']),
  ]),
);
final followList = client.followList(followQuery);
final page1 = await followList.get();
final page2 = await followList.queryMoreFollows();
final page1And2 = followList.state.follows;
// Paginating through followers for a feed
// My feed is timeline:john
const followerQuery = FollowsQuery(
  filter: Filter.equal(FollowsFilterField.targetFeed, 'timeline:john'),
);
final followerList = client.followList(followerQuery);
final followerPage1 = await followerList.get();

const myTimeline = client.feeds.feed("timeline", "john");
await myTimeline.getOrCreate({
  user_id: "john",
});
// Do I follow a list of feeds
const response = await client.feeds.queryFollows({
  filter: {
    source_feed: myTimeline.feed,
    target_feed: { $in: ["user:sara", "user:adam"] },
  },
});

console.log(response.follows);

const userFeed = client.feeds.feed("user", "john");
await userFeed.getOrCreate({
  user_id: "john",
});

// Paginating through followers for a feed
const firstPage = await client.feeds.queryFollows({
  filter: { target_feed: userFeed.feed },
  limit: 20,
});

// Next page
const secondPage = await client.feeds.queryFollows({
  filter: { target_feed: userFeed.feed },
  limit: 20,
  next: firstPage.next,
});

// Filter by source - feeds that I follow
await client.feeds.queryFollows({
  filter: { source_feed: myTimeline.feed },
  limit: 20,
});

ctx := context.Background()

// Create timeline feed
myTimeline := client.Feeds().Feed("timeline", "john")
_, err = myTimeline.GetOrCreate(ctx, &getstream.GetOrCreateFeedRequest{
  UserID: getstream.PtrTo("john"),
})
if err != nil {
  log.Fatal("Error creating timeline feed:", err)
}

// Query follows to check if we follow a list of feeds
response, err := client.Feeds().QueryFollows(ctx, &getstream.QueryFollowsRequest{
  Filter: map[string]any{
    "source_feed": "timeline:john",
    "target_feed": map[string]any{
      "$in": []string{"user:sara", "user:adam"},
    },
  },
})
if err != nil {
  log.Fatal("Error querying follows:", err)
}
log.Printf("Follows: %+v", response.Data.Follows)

// Create user feed
userFeed := client.Feeds().Feed("user", "john")
_, err = userFeed.GetOrCreate(ctx, &getstream.GetOrCreateFeedRequest{
  UserID: getstream.PtrTo("john"),
})
if err != nil {
  log.Fatal("Error creating user feed:", err)
}

// Paginating through followers for a feed - first page
firstPage, err := client.Feeds().QueryFollows(ctx, &getstream.QueryFollowsRequest{
  Filter: map[string]any{
    "target_feed": "user:john",
  },
  Limit: getstream.PtrTo(20),
})
if err != nil {
  log.Fatal("Error querying first page of follows:", err)
}

// Next page
secondPage, err := client.Feeds().QueryFollows(ctx, &getstream.QueryFollowsRequest{
  Filter: map[string]any{
    "target_feed": "user:john",
  },
  Limit: getstream.PtrTo(20),
  Next:  firstPage.Data.Next,
})
if err != nil {
  log.Fatal("Error querying second page of follows:", err)
}
log.Printf("First page follows: %+v", firstPage.Data.Follows)
log.Printf("Second page follows: %+v", secondPage.Data.Follows)

// Filter by source - feeds that I follow
sourceFollows, err := client.Feeds().QueryFollows(ctx, &getstream.QueryFollowsRequest{
  Filter: map[string]any{
    "source_feed": "timeline:john",
  },
  Limit: getstream.PtrTo(20),
})
if err != nil {
  log.Fatal("Error querying source follows:", err)
}
log.Printf("Source follows: %+v", sourceFollows.Data.Follows)

// Query follows
QueryFollowsRequest request = QueryFollowsRequest.builder().limit(10).build();
QueryFollowsResponse response = feeds.queryFollows(request).execute().getData();

$myTimeline = $feedsClient->feed('timeline', 'john');
$myTimeline->getOrCreateFeed(
    new GeneratedModels\GetOrCreateFeedRequest(userID: 'john')
);

// Do I follow a list of feeds
$response = $feedsClient->queryFollows(
    new GeneratedModels\QueryFollowsRequest(
        filter: (object)[
            'source_feed' => 'timeline:john',
            'target_feed' => (object)['$in' => ['user:sara', 'user:adam']]
        ]
    )
);

echo json_encode($response->getData()->follows);

$userFeed = $feedsClient->feed('user', 'john');
$userFeed->getOrCreateFeed(
    new GeneratedModels\GetOrCreateFeedRequest(userID: 'john')
);

// Paginating through followers for a feed
$firstPage = $feedsClient->queryFollows(
    new GeneratedModels\QueryFollowsRequest(
        filter: (object)['target_feed' => 'user:john'],
        limit: 20
    )
);

// Next page
$secondPage = $feedsClient->queryFollows(
    new GeneratedModels\QueryFollowsRequest(
        filter: (object)['target_feed' => 'user:john'],
        limit: 20,
        next: $firstPage->getData()->next
    )
);

// Filter by source - feeds that I follow
$sourceFollows = $feedsClient->queryFollows(
    new GeneratedModels\QueryFollowsRequest(
        filter: (object)['source_feed' => 'timeline:john'],
        limit: 20
    )
);

// Query follows
var response = await _feedsV3Client.QueryFollowsAsync(
    new QueryFollowsRequest
    {
        Limit = 10
    }
);

# Query follows
response = self.client.feeds.query_follows(
    limit=10,
    filter={
        "source_feed": f"{self.USER_FEED_TYPE}:{self.test_user_id}"
    }
)

# Query follows
query_request = GetStream::Generated::Models::QueryFollowsRequest.new(
  limit: 10,
)

query_response = client.feeds.query_follows(query_request)

Follows Queryable Built-In Fields

name	type	description	supported operations	example
`source_feed`	string or list of strings	The feed ID that is following	`$in`, `$eq`	`{ source_feed: { $eq: 'messaging:general' } }`
`target_feed`	string or list of strings	The feed ID being followed	`$in`, `$eq`	`{ target_feed: { $in: [ 'sports:news', 'tech:updates' ] } }`
`status`	string or list of strings	The follow status	`$in`, `$eq`	`{ status: { $in: [ 'accepted', 'pending', 'rejected' ] } }`
`created_at`	string, must be formatted as an RFC3339 timestamp	The time the follow relationship was created	`$eq`, `$gt`, `$gte`, `$lt`, `$lte`	`{ created_at: { $gte: '2023-12-04T09:30:20.45Z' } }`

Follow Requests

Some apps require the user’s approval for following them.

// Sara needs to configure the feed with visibility = followers for enabling follow requests
let saraFeed = saraClient.feed(
    for: .init(
        group: "user",
        id: "sara",
        data: .init(visibility: .followers)
    )
)
try await saraFeed.getOrCreate()

// Adam requesting to follow the feed
let adamTimeline = adamClient.feed(group: "timeline", id: "adam")
try await adamTimeline.getOrCreate()

let followRequest = try await adamTimeline.follow(saraFeed.feed) // user:sara
print(followRequest.status) // .pending

// Sara accepting
try await saraFeed.acceptFollow(
    adamTimeline.feed, // timeline:adam
    role: "feed_member" // optional
)
// or rejecting the request
try await saraFeed.rejectFollow(adamTimeline.feed) // timeline:adam

// Sara needs to configure the feed with visibility = followers for enabling follow requests
val saraFeed = saraClient.feed(
    query = FeedQuery(
        group = "user",
        id = "sara",
        data = FeedInputData(visibility = FeedVisibility.Followers)
    )
)
saraFeed.getOrCreate()

// Adam requesting to follow the feed
val adamTimeline = adamClient.feed(group = "timeline", id = "adam")
adamTimeline.getOrCreate()

val followRequest = adamTimeline.follow(saraFeed.fid) // user:sara
println(followRequest.getOrNull()?.status) // FollowStatus.PENDING

// Sara accepting
saraFeed.acceptFollow(
    sourceFid = adamTimeline.fid, // timeline:adam
    role = "feed_member" // optional
)
// or rejecting the request
saraFeed.rejectFollow(adamTimeline.fid) // timeline:adam

const saraFeed = saraClient.feed("user", uuidv4());
await saraFeed.getOrCreate({
  // You need to set followers visibility to have follow requests
  data: { visibility: "followers" },
});

const adamTimeline = adamClient.feed("timeline", uuidv4());
await adamTimeline.getOrCreate();

const followRequest = await adamTimeline.follow(saraFeed.feed);

console.log(followRequest.follow.status); // pending

await saraClient.acceptFollow({
  source: adamTimeline.feed,
  target: saraFeed.feed,
  // Optionally provide role
  follower_role: "feed_member",
});

await saraClient.rejectFollow({
  source: adamTimeline.feed,
  target: saraFeed.feed,
});

// Sara needs to configure the feed with visibility = followers for enabling follow requests
const saraFeedQuery = FeedQuery(
  fid: FeedId(group: 'user', id: 'sara'),
  data: FeedInputData(visibility: FeedVisibility.followers),
);
final saraFeed = saraClient.feedFromQuery(saraFeedQuery);
await saraFeed.getOrCreate();

// Adam requesting to follow the feed
final adamTimeline = adamClient.feed(group: 'timeline', id: 'adam');
await adamTimeline.getOrCreate();
final followRequest =
    await adamTimeline.follow(targetFid: saraFeed.fid); // user:sara
print(followRequest.getOrNull()?.status); // .pending
// Sara accepting
await saraFeed.acceptFollow(
  sourceFid: adamTimeline.fid, // timeline:adam
  role: 'feed_member', // optional
);
// or rejecting the request
await saraFeed.rejectFollow(sourceFid: adamTimeline.fid); // timeline:adam

const saraFeed = client.feeds.feed("user", uuidv4());
await saraFeed.getOrCreate({
  // You need to set followers visibility to have follow requests
  data: { visibility: "followers" },
  user_id: 'sara'
});

const adamTimeline = client.feeds.feed("timeline", uuidv4());
await adamTimeline.getOrCreate({
  user_id:
});

const followRequest = await client.feeds.follow({
  source: adamTimeline.feed,
  target: saraFeed.feed,
});

console.log(followRequest.follow.status); // pending

await client.feeds.acceptFollow({
  source: adamTimeline.feed,
  target: saraFeed.feed,
  // Optionally provide role
  follower_role: "feed_member",
});

await client.feeds.rejectFollow({
  source: adamTimeline.feed,
  target: saraFeed.feed,
});

ctx := context.Background()

saraFeed := client.Feeds().Feed("user", "sara")
_, err = saraFeed.GetOrCreate(ctx, &getstream.GetOrCreateFeedRequest{
  Data: &getstream.FeedInput{
    Visibility: getstream.PtrTo("followers"),
  },
  UserID: getstream.PtrTo("sara"),
})
if err != nil {
  log.Fatal("Error creating sara feed:", err)
}

adamTimeline := client.Feeds().Feed("timeline", "adam")
_, err = adamTimeline.GetOrCreate(ctx, &getstream.GetOrCreateFeedRequest{
  UserID: getstream.PtrTo("adam"),
})
if err != nil {
  log.Fatal("Error creating adam timeline feed:", err)
}

// Create follow request from adamTimeline to saraFeed
followRequest, err := client.Feeds().Follow(ctx, &getstream.FollowRequest{
  Source: "timeline:adam",
  Target: "user:sara",
})
if err != nil {
  log.Fatal("Error creating follow request:", err)
}
fmt.Printf("Follow request status: %s\n", followRequest.Data.Follow.Status)

// Accept follow request and set follower's role
_, err = client.Feeds().AcceptFollow(ctx, &getstream.AcceptFollowRequest{
  Source:       "timeline:adam",
  Target:       "user:sara",
  FollowerRole: getstream.PtrTo("feed_member"),
})
if err != nil {
  log.Fatal("Error accepting follow request:", err)
}

// Reject follow request
_, err = client.Feeds().RejectFollow(ctx, &getstream.RejectFollowRequest{
  Source: "timeline:adam",
  Target: "user:sara",
})
if err != nil {
  log.Fatal("Error rejecting follow request:", err)
}

// Sara needs to configure the feed with visibility = followers for enabling follow requests
GetOrCreateFeedRequest saraFeedRequest = GetOrCreateFeedRequest.builder()
    .userID("sara")
    .data(FeedInput.builder()
        .visibility("followers")
        .build())
    .build();
feeds.getOrCreateFeed("user", "sara", saraFeedRequest).execute();

// Adam requesting to follow the feed
GetOrCreateFeedRequest adamFeedRequest = GetOrCreateFeedRequest.builder()
    .userID("adam")
    .build();
feeds.getOrCreateFeed("timeline", "adam", adamFeedRequest).execute();

// Create follow request from adamTimeline to saraFeed
FollowRequest followRequest = FollowRequest.builder()
    .source("timeline:adam")
    .target("user:sara")
    .build();
SingleFollowResponse followResponse = feeds.follow(followRequest).execute().getData();
System.out.println(followResponse.getFollow().getStatus()); // pending

// Sara accepting
AcceptFollowRequest acceptRequest = AcceptFollowRequest.builder()
    .source("timeline:adam")
    .target("user:sara")
    .followerRole("feed_member") // optional
    .build();
feeds.acceptFollow(acceptRequest).execute();

// or rejecting the request
RejectFollowRequest rejectRequest = RejectFollowRequest.builder()
    .source("timeline:adam")
    .target("user:sara")
    .build();
feeds.rejectFollow(rejectRequest).execute();

// Sara needs to configure the feed with visibility = followers for enabling follow requests
$saraFeed = $feedsClient->feed('user', 'sara');
$saraFeed->getOrCreateFeed(
    new GeneratedModels\GetOrCreateFeedRequest(
        userID: 'sara',
        data: new GeneratedModels\FeedInput(visibility: 'followers')
    )
);

// Adam requesting to follow the feed
$adamTimeline = $feedsClient->feed('timeline', 'adam');
$adamTimeline->getOrCreateFeed(
    new GeneratedModels\GetOrCreateFeedRequest(userID: 'adam')
);

$followRequest = $feedsClient->follow(
    new GeneratedModels\FollowRequest(
        source: 'timeline:adam',
        target: 'user:sara'
    )
);
echo $followRequest->getData()->follow->status; // pending

// Sara accepting
$acceptResponse = $feedsClient->acceptFollow(
    new GeneratedModels\AcceptFollowRequest(
        source: 'timeline:adam',
        target: 'user:sara',
        followerRole: 'feed_member' // optional
    )
);

// or rejecting the request
$rejectResponse = $feedsClient->rejectFollow(
    new GeneratedModels\RejectFollowRequest(
        source: 'timeline:adam',
        target: 'user:sara'
    )
);

// Sara needs to configure the feed with visibility = followers for enabling follow requests
await _feedsV3Client.GetOrCreateFeedAsync(
    FeedGroupID: "user",
    FeedID: "sara",
    request: new GetOrCreateFeedRequest
    {
        UserID = "sara",
        Data = new FeedInput { Visibility = "followers" }
    }
);

// Adam requesting to follow the feed
await _feedsV3Client.GetOrCreateFeedAsync(
    FeedGroupID: "timeline",
    FeedID: "adam",
    request: new GetOrCreateFeedRequest { UserID = "adam" }
);

// Create follow request from adamTimeline to saraFeed
var followResponse = await _feedsV3Client.FollowAsync(
    new FollowRequest
    {
        Source = "timeline:adam",
        Target = "user:sara"
    }
);
Console.WriteLine(followResponse.Follow.Status); // pending

// Sara accepting
await _feedsV3Client.AcceptFollowAsync(
    new AcceptFollowRequest
    {
        Source = "timeline:adam",
        Target = "user:sara",
        FollowerRole = "feed_member" // optional
    }
);

// or rejecting the request
await _feedsV3Client.RejectFollowAsync(
    new RejectFollowRequest
    {
        Source = "timeline:adam",
        Target = "user:sara"
    }
);

# Sara needs to configure the feed with visibility = followers for enabling follow requests
feeds.get_or_create_feed(
    feed_group="user",
    feed_id="sara",
    user_id="sara",
    data={"visibility": "followers"}
)

# Adam requesting to follow the feed
feeds.get_or_create_feed(
    feed_group="timeline",
    feed_id="adam",
    user_id="adam"
)

# Create follow request from adamTimeline to saraFeed
follow_response = feeds.follow(
    source="timeline:adam",
    target="user:sara"
)
print(follow_response["follow"]["status"])  # pending

# Sara accepting
feeds.accept_follow(
    source="timeline:adam",
    target="user:sara",
    follower_role="feed_member"  # optional
)

# or rejecting the request
feeds.reject_follow(
    source="timeline:adam",
    target="user:sara"
)

# Sara needs to configure the feed with visibility = followers for enabling follow requests
client.feeds.get_or_create_feed(
  "user",
  "sara",
  GetStream::Generated::Models::GetOrCreateFeedRequest.new(
    user_id: "sara",
    data: { "visibility" => "followers" }
  )
)

# Adam requesting to follow the feed
client.feeds.get_or_create_feed(
  "timeline",
  "adam",
  GetStream::Generated::Models::GetOrCreateFeedRequest.new(
    user_id: "adam"
  )
)

# Create follow request from adamTimeline to saraFeed
follow_response = client.feeds.follow(
  GetStream::Generated::Models::FollowRequest.new(
    source: "timeline:adam",
    target: "user:sara"
  )
)
puts follow_response.data.follow.status  # pending

# Sara accepting
client.feeds.accept_follow(
  GetStream::Generated::Models::AcceptFollowRequest.new(
    source: "timeline:adam",
    target: "user:sara",
    follower_role: "feed_member"  # optional
  )
)

# or rejecting the request
client.feeds.reject_follow(
  GetStream::Generated::Models::RejectFollowRequest.new(
    source: "timeline:adam",
    target: "user:sara"
  )
)

Push Preferences on Follow

When following a feed, you can set push_preference to control push notifications for future activities from that feed:

all - Receive push notifications for all activities from the followed feed
none (default) - Don’t receive push notifications for activities from the followed feed

Note: The push_preference parameter controls future notifications from the followed feed, while skip_push controls whether the follow action itself triggers a notification.

Examples: Push Preferences vs Skip Push

Understanding the difference between push_preference and skip_push:

// Scenario 1: Follow a user and receive notifications for their future activities
await timeline.follow("user:alice", {
  push_preference: "all", // You'll get push notifications for Alice's future posts
});

// Scenario 2: Follow a user but don't get notifications for their activities
await timeline.follow("user:bob", {
  push_preference: "none", // You won't get push notifications for Bob's future posts
});

// Scenario 3: Follow a user silently
await timeline.follow("user:charlie", {
  skip_push: true, // Charlie won't get a "you have a new follower" notification
  push_preference: "all", // But you'll still get notifications for Charlie's future posts
});

// Scenario 4: Silent follow with no future notifications
await timeline.follow("user:diana", {
  skip_push: true, // Diana won't know you followed her
  push_preference: "none", // And you won't get notifications for her posts
});

Follow Suggestions

Stream provides intelligent follow suggestions to help users discover feeds they might want to follow based on their activity and social graph.

// Get follow suggestions for a user
let suggestions = try await client.getFollowSuggestions(
    feedGroupId: "user",
    limit: 10,
    userId: "john"
)

for suggestion in suggestions.suggestions {
    print("Suggested feed: \(suggestion.fid)")
    print("Recommendation score: \(suggestion.recommendationScore)")
    print("Reason: \(suggestion.reason)")
}

// Get follow suggestions for a user
val suggestions = client.getFollowSuggestions(
    feedGroupId = "user",
    limit = 10,
    userId = "john"
)

suggestions.suggestions.forEach { suggestion ->
    println("Suggested feed: ${suggestion.fid}")
    println("Recommendation score: ${suggestion.recommendationScore}")
    println("Reason: ${suggestion.reason}")
}

// Get follow suggestions for a user
const suggestions = await client.getFollowSuggestions({
  feed_group_id: "user",
  limit: 10,
});

console.log("Algorithm used:", suggestions.algorithm_used);
console.log("Duration:", suggestions.duration);

suggestions.suggestions.forEach((suggestion) => {
  console.log("Suggested feed:", suggestion.feed);
  console.log("Name:", suggestion.name);
  console.log("Description:", suggestion.description);
  console.log("Follower count:", suggestion.follower_count);
  console.log("Recommendation score:", suggestion.recommendation_score);
  console.log("Reason:", suggestion.reason);
  console.log("Algorithm scores:", suggestion.algorithm_scores);
});

// Get follow suggestions for a user
final suggestions = await client.getFollowSuggestions(
  feedGroupId: 'user',
  limit: 10,
  userId: 'john',
);

print('Algorithm used: ${suggestions.algorithmUsed}');
print('Duration: ${suggestions.duration}');

for (final suggestion in suggestions.suggestions) {
  print('Suggested feed: ${suggestion.fid}');
  print('Name: ${suggestion.name}');
  print('Description: ${suggestion.description}');
  print('Follower count: ${suggestion.followerCount}');
  print('Recommendation score: ${suggestion.recommendationScore}');
  print('Reason: ${suggestion.reason}');
  print('Algorithm scores: ${suggestion.algorithmScores}');
}

// Get follow suggestions for a user
const suggestions = await client.feeds.getFollowSuggestions({
  feed_group_id: "user",
  limit: 10,
  user_id: "john",
});

console.log("Algorithm used:", suggestions.algorithm_used);
console.log("Duration:", suggestions.duration);

suggestions.suggestions.forEach((suggestion) => {
  console.log("Suggested feed:", suggestion.feed);
  console.log("Name:", suggestion.name);
  console.log("Description:", suggestion.description);
  console.log("Follower count:", suggestion.follower_count);
  console.log("Recommendation score:", suggestion.recommendation_score);
  console.log("Reason:", suggestion.reason);
  console.log("Algorithm scores:", suggestion.algorithm_scores);
});

// Get follow suggestions for a user
suggestions, err := client.Feeds().GetFollowSuggestions(context.Background(), &getstream.GetFollowSuggestionsRequest{
    FeedGroupId: "user",
    Limit:       getstream.PtrTo(10),
    UserId:      getstream.PtrTo("john"),
})
if err != nil {
    log.Fatal("Error getting follow suggestions:", err)
}

fmt.Printf("Algorithm used: %s\n", suggestions.Data.AlgorithmUsed)
fmt.Printf("Duration: %s\n", suggestions.Data.Duration)

for _, suggestion := range suggestions.Data.Suggestions {
    fmt.Printf("Suggested feed: %s\n", suggestion.Fid)
    fmt.Printf("Name: %s\n", suggestion.Name)
    fmt.Printf("Description: %s\n", suggestion.Description)
    fmt.Printf("Follower count: %d\n", suggestion.FollowerCount)
    fmt.Printf("Recommendation score: %.2f\n", suggestion.RecommendationScore)
    fmt.Printf("Reason: %s\n", suggestion.Reason)
    fmt.Printf("Algorithm scores: %+v\n", suggestion.AlgorithmScores)
}

// Get follow suggestions for a user
GetFollowSuggestionsRequest request = GetFollowSuggestionsRequest.builder()
    .feedGroupId("user")
    .limit(10)
    .userId("john")
    .build();

GetFollowSuggestionsResponse response = feeds.getFollowSuggestions(request).execute().getData();

System.out.println("Algorithm used: " + response.getAlgorithmUsed());
System.out.println("Duration: " + response.getDuration());

for (FollowSuggestion suggestion : response.getSuggestions()) {
    System.out.println("Suggested feed: " + suggestion.getFid());
    System.out.println("Name: " + suggestion.getName());
    System.out.println("Description: " + suggestion.getDescription());
    System.out.println("Follower count: " + suggestion.getFollowerCount());
    System.out.println("Recommendation score: " + suggestion.getRecommendationScore());
    System.out.println("Reason: " + suggestion.getReason());
    System.out.println("Algorithm scores: " + suggestion.getAlgorithmScores());
}

// Get follow suggestions for a user
$suggestions = $feedsClient->getFollowSuggestions(
    new GeneratedModels\GetFollowSuggestionsRequest(
        feedGroupId: 'user',
        limit: 10,
        userId: 'john'
    )
);

echo "Algorithm used: " . $suggestions->getData()->algorithmUsed . "\n";
echo "Duration: " . $suggestions->getData()->duration . "\n";

foreach ($suggestions->getData()->suggestions as $suggestion) {
    echo "Suggested feed: " . $suggestion->fid . "\n";
    echo "Name: " . $suggestion->name . "\n";
    echo "Description: " . $suggestion->description . "\n";
    echo "Follower count: " . $suggestion->followerCount . "\n";
    echo "Recommendation score: " . $suggestion->recommendationScore . "\n";
    echo "Reason: " . $suggestion->reason . "\n";
    echo "Algorithm scores: " . json_encode($suggestion->algorithmScores) . "\n";
}

// Get follow suggestions for a user
var response = await _feedsV3Client.GetFollowSuggestionsAsync(
    new GetFollowSuggestionsRequest
    {
        FeedGroupId = "user",
        Limit = 10,
        UserId = "john"
    }
);

Console.WriteLine($"Algorithm used: {response.AlgorithmUsed}");
Console.WriteLine($"Duration: {response.Duration}");

foreach (var suggestion in response.Suggestions)
{
    Console.WriteLine($"Suggested feed: {suggestion.Fid}");
    Console.WriteLine($"Name: {suggestion.Name}");
    Console.WriteLine($"Description: {suggestion.Description}");
    Console.WriteLine($"Follower count: {suggestion.FollowerCount}");
    Console.WriteLine($"Recommendation score: {suggestion.RecommendationScore}");
    Console.WriteLine($"Reason: {suggestion.Reason}");
    Console.WriteLine($"Algorithm scores: {JsonSerializer.Serialize(suggestion.AlgorithmScores)}");
}

# Get follow suggestions for a user
suggestions = client.feeds.get_follow_suggestions(
    feed_group_id="user",
    limit=10,
    user_id="john"
)

print(f"Algorithm used: {suggestions.algorithm_used}")
print(f"Duration: {suggestions.duration}")

for suggestion in suggestions.suggestions:
    print(f"Suggested feed: {suggestion.fid}")
    print(f"Name: {suggestion.name}")
    print(f"Description: {suggestion.description}")
    print(f"Follower count: {suggestion.follower_count}")
    print(f"Recommendation score: {suggestion.recommendation_score}")
    print(f"Reason: {suggestion.reason}")
    print(f"Algorithm scores: {suggestion.algorithm_scores}")

# Get follow suggestions for a user
suggestions = client.feeds.get_follow_suggestions(
  feed_group_id: 'user',
  limit: 10,
  user_id: 'john'
)

puts "Algorithm used: #{suggestions.algorithm_used}"
puts "Duration: #{suggestions.duration}"

suggestions.suggestions.each do |suggestion|
  puts "Suggested feed: #{suggestion.fid}"
  puts "Name: #{suggestion.name}"
  puts "Description: #{suggestion.description}"
  puts "Follower count: #{suggestion.follower_count}"
  puts "Recommendation score: #{suggestion.recommendation_score}"
  puts "Reason: #{suggestion.reason}"
  puts "Algorithm scores: #{suggestion.algorithm_scores}"
end

Response Fields

The follow suggestions response includes:

suggestions: Array of suggested feeds to follow
- feed: Feed identifier
- name: Feed name
- description: Feed description
- visibility: Feed visibility setting
- member_count: Number of members
- follower_count: Number of followers
- following_count: Number of feeds this feed follows
- created_at: When the feed was created
- updated_at: When the feed was last updated
- recommendation_score: Combined recommendation score (0-1)
- reason: Human-readable reason for the suggestion
- algorithm_scores: Individual algorithm scores
algorithm_used: The algorithm used to generate suggestions
duration: Request processing time

Algorithm Types

Stream’s follow suggestions use a sophisticated multi-algorithm approach with weighted scoring:

popularity (Weight: 0.3): Based on follower count and engagement
- Calculates normalized follower count relative to the most popular feed in your app
- Score = min(follower_count / max_follower_count, 1.0)
- Helps surface trending and popular content
friend-of-friend (Weight: 0.7): Based on social connections and mutual follows
- Analyzes how many of your followed feeds also follow the suggested feed
- Score = mutual_follows / your_total_follows
- Leverages social proof and network effects
combined: Uses multiple algorithms with weighted scoring
- Final score = (popularity_score × 0.3 + friend_of_friend_score × 0.7) / total_weight
- Provides balanced recommendations combining popularity and social relevance

Note: Additional algorithms will be added in future releases to provide even more sophisticated recommendations.

Scoring System

The recommendation system uses a sophisticated scoring mechanism:

Individual Algorithm Scores: Each algorithm calculates a score from 0.0 to 1.0
Weighted Combination: Scores are combined using configurable weights
Normalization: Final scores are normalized to ensure fair comparison
Filtering: Only feeds with positive combined scores are included
Ranking: Results are sorted by combined score in descending order

Features

Excludes feeds already followed by the user
Excludes user’s own feeds
Sophisticated algorithm to find feeds to follow

Built-in fields of follows

FollowResponse

Name	Type	Description	Constraints
`created_at`	`number`	When the follow relationship was created	Required
`custom`	`object`	Custom data for the follow relationship	-
`follower_role`	`string`	Role of the follower (source user) in the follow relationship	Required
`push_preference`	`string (all, none)`	Push preference for notifications	Required
`request_accepted_at`	`number`	When the follow request was accepted	-
`request_rejected_at`	`number`	When the follow request was rejected	-
`source_feed`	`FeedResponse`	Source feed object	Required
`status`	`string (accepted, pending, rejected)`	Status of the follow relationship	Required
`target_feed`	`FeedResponse`	Target feed object	Required
`updated_at`	`number`	When the follow relationship was last updated	Required

Feed and Activity Visibility

Membership levels