Activity Feeds v3 is in beta — try it out!

Feed views

When to use feed views

Feed groups let you define what activities should be included in the feed and the ranking to sort these activities.

By default all feeds in the given group will have the same settings. However, you might want to experiment with different selectors and rankings. Feed views let you do that by overriding the group’s default settings.

Note that any write operation to feed groups/views can take up to 30 seconds to propagate to all API nodes.

Applications can’t have more than 100 feed views

Feed view operations are only available on server-side.

await serverClient.feeds.createFeedView({
  id: "<view id>",
  activity_selectors: [
    {
      type: "following",
    },
  ],
  ranking: { type: "recency" },
});

viewId := "myview"
_, err = client.Feeds().CreateFeedView(context.Background(), &getstream.CreateFeedViewRequest{
    ID: viewId,
    ActivitySelectors: []getstream.ActivitySelectorConfig{
        {
            Type: getstream.PtrTo("following"),
        },
    },
    Ranking: &getstream.RankingConfig{
        Type: getstream.PtrTo("recency"),
    },
})

if err != nil {
    log.Fatal("Error creating feed view:", err)
}

$createResponse = $feedsClient->createFeedView(new GeneratedModels\CreateFeedViewRequest(
    id: "myview",
    activitySelectors: [
        new GeneratedModels\ActivitySelectorConfig(
            type: "following"
        )
    ],
    ranking: new GeneratedModels\RankingConfig(
        type: "recency"
    )
));

var createResponse = await _feedsV3Client.CreateFeedViewAsync(new CreateFeedViewRequest
{
    ID = feedViewId,
    ActivitySelectors = new List<ActivitySelectorConfig>
    {
        new() { Type = "recent" }
    },
    ActivityProcessors = new List<ActivityProcessorConfig>
    {
        new() { Type = "default" }
    },
    Aggregation = new AggregationConfig
    {
        Format = "time_based"
    }
});

create_response = self.client.feeds.create_feed_view(
    id = feed_view_id,
    activity_selectors= [
        {
            "type": "recent"
        }
    ],
)

require 'getstream_ruby'

create_response = client.feeds.create_feed_view(
  GetStream::Generated::Models::CreateFeedViewRequest.new(
    id: 'myview',
    activity_selectors: [
      GetStream::Generated::Models::ActivitySelectorConfig.new(type: 'following')
    ],
    ranking: GetStream::Generated::Models::RankingConfig.new(type: 'recency')
  )
)

let query = FeedQuery(
    group: "user",
    id: "john",
    view: "<id of a feed view>", // Override the default view id
)
let feed = client.feed(for: query)
try await feed.getOrCreate()

val query = FeedQuery(
    group = "user",
    id = "john",
    view = "<id of a feed view>" // Override the default view id
)
val feed = client.feed(query = query)
feed.getOrCreate()

feed.getOrCreate({
  // Override the default view id
  view: "<id of a feed view>",
});

const query = FeedQuery(
  fid: FeedId(group: 'user', id: 'john'),
  view: '<id of a feed view>', // Override the default view id
);
final feed = client.feedFromQuery(query);
await feed.getOrCreate();

feed.getOrCreate({
  // Override the default view id
  view: "<id of a feed view>",
  user_id: "<user id>",
});

_, err = feed.GetOrCreate(context.Background(), &getstream.GetOrCreateFeedRequest{
    View: getstream.PtrTo("<view id>"),
    UserID: getstream.PtrTo("<user id>"),
})
if err != nil {
 log.Fatal("Error:", err)
}

testFeed = new Feed("user", testUserId, feeds);
testFeed2 = new Feed("user", testUserId2, feeds);

GetOrCreateFeedRequest feedRequest1 =
    GetOrCreateFeedRequest.builder().userID(testUserId).build();
GetOrCreateFeedRequest feedRequest2 =
    GetOrCreateFeedRequest.builder().userID(testUserId2).build();

GetOrCreateFeedResponse feedResponse1 = testFeed.getOrCreate(feedRequest1).getData();
GetOrCreateFeedResponse feedResponse2 = testFeed2.getOrCreate(feedRequest2).getData();
testFeedId = feedResponse1.getFeed().getFeed();
testFeedId2 = feedResponse2.getFeed().getFeed();

$feedResponse = $feedsClient->getOrCreateFeed(
    "user",
    "john",
    new GeneratedModels\GetOrCreateFeedRequest(
        view: "<id of a feed view>",
        userID: "<user id>"
    )
);

var feedResponse1 = await _feedsV3Client.GetOrCreateFeedAsync(
    FeedGroupID: "user",
    FeedID: _testFeedId,
    request: new GetOrCreateFeedRequest { UserID = _testUserId }
);
var feedResponse2 = await _feedsV3Client.GetOrCreateFeedAsync(
    FeedGroupID: "user",
    FeedID: _testFeedId2,
    request: new GetOrCreateFeedRequest { UserID = _testUserId2 }
);

feed_response_1 = self.test_feed.get_or_create(user_id=self.test_user_id)
feed_response_2 = self.test_feed_2.get_or_create(
    user_id=self.test_user_id_2
)

With custom feed views you can control

Activity selectors
Ranking
Aggregation

List feed views

To list existing feed views and their configurations:

await client.feeds.listFeedViews();

Updating feed views

It’s possible to update any custom or built-in feed views.

await serverClient.feeds.updateFeedView({
  id: "<view id to update>",
  // Fields to update
});

_, err = client.Feeds().UpdateFeedView(context.Background(), viewId, &getstream.UpdateFeedViewRequest{
    // Fields to update
})
if err != nil {
    log.Fatal("Error:", err)
}

$updateResponse = $feedsClient->updateFeedView('feedViewID', new GeneratedModels\UpdateFeedViewRequest(
    // Fields to update
));

var updateResponse = await _feedsV3Client.UpdateFeedViewAsync("feedViewID", new UpdateFeedViewRequest
{
    ActivitySelectors = new List<ActivitySelectorConfig>
    {
        new() { Type = "popular", MinPopularity = 10 }
    },
    Aggregation = new AggregationConfig
    {
        Format = "popularity_based"
    }
});

update_response = self.client.feeds.update_feed_view(
    id="feedViewID",
    activity_selectors= [
        {
            "type": "popular",
            "min_popularity": 10
        }
    ]
)

require 'getstream_ruby'

update_request = GetStream::Generated::Models::UpdateFeedViewRequest.new(
  # Fields to update
  # activity_selectors: [...],
  # activity_processors: [...],
  # aggregation: GetStream::Generated::Models::AggregationConfig.new(...),
  # ranking: GetStream::Generated::Models::RankingConfig.new(...)
)

response = client.feeds.update_feed_view('feedViewID', update_request)

Deleting feed views

await serverClient.feeds.deleteFeedView({
  id: "view id to delete",
});

_, err = client.Feeds().DeleteFeedView(context.Background(), viewId, &getstream.DeleteFeedViewRequest{})

$deleteResponse = $feedsClient->deleteFeedView('viewID-123');

await _feedsV3Client.DeleteFeedViewAsync("viewID-123");

# self.client.feeds.delete_feed_view("viewID-123")

require 'getstream_ruby'

client.feeds.delete_feed_view('viewID-123')

Intro & Defaults

Aggregation