Activity Feeds v3 is in beta — try it out!

Search for Feeds

The query feeds endpoint lets you search for feeds.

Examples

Querying My Feeds

let query = FeedsQuery(  filter: .equal(.createdById, "john"),  sort: [Sort(field: .createdAt, direction: .reverse)],  limit: 10,  watch: true ) let feedList = client.feedList(for: query) // Page 1 let page1 = try await feedList.get()  // Page 2 let page2 = try await feedList.queryMoreFeeds(limit: 10)  let page1And2 = feedList.state.feeds

val query = FeedsQuery(  filter = FeedsFilterField.createdById.equal("john"),  sort = listOf(FeedsSort(FeedsSortField.CreatedAt, SortDirection.REVERSE)),  limit = 10,  watch = true ) val feedList = client.feedList(query = query) // Page 1 val page1: Result<List<FeedData>> = feedList.get()  // Page 2 val page2: Result<List<FeedData>> = feedList.queryMoreFeeds(limit = 10)  val page1And2 = feedList.state.feeds

const firstPage = await client.queryFeeds({  filter: {  created_by_id: "john",  },  limit: 10,  sort: [{ field: "created_at", direction: -1 }], });  const secondPage = await client.queryFeeds({  filter: {  created_by_id: "john",  },  limit: 10,  sort: [{ field: "created_at", direction: -1 }],  next: firstPage.next, });

final query = FeedsQuery(  filter: const Filter.equal(FeedsFilterField.createdById, 'john'),  sort: [FeedsSort.desc(FeedsSortField.createdAt)],  limit: 10,  watch: true, );  final feedList = client.feedList(query);  // Page 1 final page1 = await feedList.get();  // Page 2 final page2 = await feedList.queryMoreFeeds(limit: 10);  final page1And2 = feedList.state.feeds;

const firstPage = await client.feeds.queryFeeds({  filter: {  created_by_id: "john",  },  limit: 10,  sort: [{ field: "created_at", direction: -1 }], });  const secondPage = await client.feeds.queryFeeds({  filter: {  created_by_id: "john",  },  limit: 10,  sort: [{ field: "created_at", direction: -1 }],  next: firstPage.next, });

ctx := context.Background()  // First page query firstPage, err := client.Feeds().QueryFeeds(ctx, &getstream.QueryFeedsRequest{  Filter: map[string]any{  "created_by_id": "john",  },  Limit: getstream.PtrTo(10),  Sort: []getstream.SortParamRequest{  {  Field: getstream.PtrTo("created_at"),  Direction: getstream.PtrTo(-1),  },  }, }) if err != nil {  log.Fatal("Error querying first page:", err) }  // Second page query using next cursor from first page secondPage, err := client.Feeds().QueryFeeds(ctx, &getstream.QueryFeedsRequest{  Filter: map[string]any{  "created_by_id": "john",  },  Limit: getstream.PtrTo(10),  Sort: []getstream.SortParamRequest{  {  Field: getstream.PtrTo("created_at"),  Direction: getstream.PtrTo(-1),  },  },  Next: firstPage.Data.Next, }) if err != nil {  log.Fatal("Error querying second page:", err) }  log.Printf("First page: %d feeds, next: %v", len(firstPage.Data.Feeds), firstPage.Data.Next) log.Printf("Second page: %d feeds, next: %v", len(secondPage.Data.Feeds), secondPage.Data.Next)

// First page query Map<String, Object> filter = new HashMap<>(); filter.put("created_by_id", "john");  QueryFeedsRequest firstPageRequest = QueryFeedsRequest.builder()  .filter(filter)  .limit(10)  .sort(List.of(  SortParamRequest.builder()  .field("created_at")  .direction(-1)  .build()  ))  .build();  QueryFeedsResponse firstPage = feeds.queryFeeds(firstPageRequest).execute().getData();  // Second page using next cursor from first page QueryFeedsRequest secondPageRequest = QueryFeedsRequest.builder()  .filter(filter)  .limit(10)  .sort(List.of(  SortParamRequest.builder()  .field("created_at")  .direction(-1)  .build()  ))  .next(firstPage.getNext())  .build();  QueryFeedsResponse secondPage = feeds.queryFeeds(secondPageRequest).execute().getData();

// First page query $firstPage = $feedsClient->queryFeeds(  new GeneratedModels\QueryFeedsRequest(  filter: (object)['created_by_id' => 'john'],  limit: 10,  sort: [  ['field' => 'created_at', 'direction' => -1]  ]  ) );  // Second page using next cursor from first page $secondPage = $feedsClient->queryFeeds(  new GeneratedModels\QueryFeedsRequest(  filter: (object)['created_by_id' => 'john'],  limit: 10,  sort: [  ['field' => 'created_at', 'direction' => -1]  ],  next: $firstPage->getData()->next  ) );

// First page query var firstPage = await _feedsV3Client.QueryFeedsAsync(  request: new QueryFeedsRequest  {  Filter = new { created_by_id = "john" },  Limit = 10,  Sort = new List<SortParamRequest>  {  new SortParamRequest  {  Field = "created_at",  Direction = -1  }  }  } );  // Second page using next cursor from first page var secondPage = await _feedsV3Client.QueryFeedsAsync(  request: new QueryFeedsRequest  {  Filter = new { created_by_id = "john" },  Limit = 10,  Sort = new List<SortParamRequest>  {  new SortParamRequest  {  Field = "created_at",  Direction = -1  }  },  Next = firstPage.Next  } );

# First page query first_page = feeds.query_feeds(  filter={"created_by_id": "john"},  limit=10,  sort=[{"field": "created_at", "direction": -1}] )  # Second page using next cursor from first page second_page = feeds.query_feeds(  filter={"created_by_id": "john"},  limit=10,  sort=[{"field": "created_at", "direction": -1}],  next=first_page["next"] )

# First page query first_page = client.feeds.query_feeds(  GetStream::Generated::Models::QueryFeedsRequest.new(  filter: { "created_by_id" => "john" },  limit: 10,  sort: [{ "field" => "created_at", "direction" => -1 }]  ) )  # Second page using next cursor from first page second_page = client.feeds.query_feeds(  GetStream::Generated::Models::QueryFeedsRequest.new(  filter: { "created_by_id" => "john" },  limit: 10,  sort: [{ "field" => "created_at", "direction" => -1 }],  _next: first_page.data._next  ) )

Querying Feeds Where I Am a Member

let query = FeedsQuery(  filter: .contains(.members, "john") ) let feedList = client.feedList(for: query) let feeds = try await feedList.get()

val query = FeedsQuery(  filter = FeedsFilterField.members.contains("john") ) val feedList = client.feedList(query = query) val feeds: Result<List<FeedData>> = feedList.get()

await client.queryFeeds({  filter: {  members: { $in: ["john"] },  }, });

const query = FeedsQuery(  filter: Filter.contains(FeedsFilterField.members, 'john'), ); final feedList = client.feedList(query); final feeds = await feedList.get();

await client.feeds.queryFeeds({  filter: {  members: { $in: ["john"] },  }, });

ctx := context.Background()  filter := map[string]any{  "members": map[string]any{  "$in": []string{"john"},  }, }  response, err := client.Feeds().QueryFeeds(ctx, &getstream.QueryFeedsRequest{  Filter: filter, }) if err != nil {  log.Fatal("Error querying feeds:", err) }  log.Printf("Query feeds response: %+v", response)

Map<String, Object> filter = new HashMap<>(); Map<String, Object> membersFilter = new HashMap<>(); membersFilter.put("$in", List.of("john")); filter.put("members", membersFilter);  QueryFeedsRequest request = QueryFeedsRequest.builder()  .filter(filter)  .build();  QueryFeedsResponse response = feeds.queryFeeds(request).execute().getData();

$response = $feedsClient->queryFeeds(  new GeneratedModels\QueryFeedsRequest(  filter: (object)[  'members' => (object)['$in' => ['john']]  ]  ) );

var response = await _feedsV3Client.QueryFeedsAsync(  request: new QueryFeedsRequest  {  Filter = new  {  members = new { __in = new[] { "john" } }  }  } );

response = feeds.query_feeds(  filter={  "members": {"$in": ["john"]}  } )

response = client.feeds.query_feeds(  GetStream::Generated::Models::QueryFeedsRequest.new(  filter: {  "members" => { "$in" => ["john"] }  }  ) )

Querying feeds by name or description

let sportsQuery = FeedsQuery(  filter: .and([  .equal(.visibility, "public"),  .query(.name, "Sports")  ]) ) let sportsFeedList = client.feedList(for: sportsQuery) let sportsFeeds = try await sportsFeedList.get()  let techQuery = FeedsQuery(  filter: .and([  .equal(.visibility, "public"),  .query(.description, "tech")  ]) ) let techFeedList = client.feedList(for: techQuery) let techFeeds = try await techFeedList.get()

val sportsQuery = FeedsQuery(  filter = Filters.and(  FeedsFilterField.visibility.equal("public"),  FeedsFilterField.name.query("Sports")  ) ) val sportsFeedList = client.feedList(query = sportsQuery) val sportsFeeds: Result<List<FeedData>> = sportsFeedList.get()  val techQuery = FeedsQuery(  filter = Filters.and(  FeedsFilterField.visibility.equal("public"),  FeedsFilterField.description.query("tech")  ) ) val techFeedList = client.feedList(query = techQuery) val techFeeds: Result<List<FeedData>> = techFeedList.get()

await client.queryFeeds({  filter: {  visibility: { $eq: "public" },  name: { $q: "Sports" },  }, });  // search public feeds by description await client.queryFeeds({  filter: {  visibility: "public",  description: { $q: "tech" },  }, });

const sportsQuery = FeedsQuery(  filter: Filter.and([  Filter.equal(FeedsFilterField.visibility, 'public'),  Filter.query(FeedsFilterField.name, 'Sports'),  ]), );  final sportsFeedList = client.feedList(sportsQuery); final sportsFeeds = await sportsFeedList.get();  const techQuery = FeedsQuery(  filter: Filter.and([  Filter.equal(FeedsFilterField.visibility, 'public'),  Filter.query(FeedsFilterField.description, 'tech'),  ]), );  final techFeedList = client.feedList(techQuery); final techFeeds = await techFeedList.get();

await client.feeds.queryFeeds({  filter: {  visibility: { $eq: "public" },  name: { $q: "Sports" },  }, });  // search public feeds by description await client.feeds.queryFeeds({  filter: {  visibility: "public",  description: { $q: "tech" },  }, });

// Create context ctx := context.Background()  response1, err := client.Feeds().QueryFeeds(ctx, &getstream.QueryFeedsRequest{  Filter: map[string]any{  "visibility": map[string]any{  "$eq": "public",  },  "name": map[string]any{  "$q": "Sports",  },  }, }) if err != nil {  log.Fatal("Error querying feeds:", err) } log.Printf("Query feeds response 1: %+v", response1)  response2, err := client.Feeds().QueryFeeds(ctx, &getstream.QueryFeedsRequest{  Filter: map[string]any{  "visibility": getstream.PtrTo("public"),  "description": map[string]any{  "$q": "tech",  },  }, })

// Search public feeds by name Map<String, Object> filter1 = new HashMap<>(); filter1.put("visibility", Map.of("$eq", "public")); filter1.put("name", Map.of("$q", "Sports"));  QueryFeedsRequest request1 = QueryFeedsRequest.builder()  .filter(filter1)  .build();  QueryFeedsResponse response1 = feeds.queryFeeds(request1).execute().getData();  // Search public feeds by description Map<String, Object> filter2 = new HashMap<>(); filter2.put("visibility", "public"); filter2.put("description", Map.of("$q", "tech"));  QueryFeedsRequest request2 = QueryFeedsRequest.builder()  .filter(filter2)  .build();  QueryFeedsResponse response2 = feeds.queryFeeds(request2).execute().getData();

// Search public feeds by name $response = $feedsClient->queryFeeds(  new GeneratedModels\QueryFeedsRequest(  filter: (object)[  'visibility' => (object)['$eq' => 'public'],  'name' => (object)['$q' => 'Sports']  ]  ) );  // Search public feeds by description $response2 = $feedsClient->queryFeeds(  new GeneratedModels\QueryFeedsRequest(  filter: (object)[  'visibility' => 'public',  'description' => (object)['$q' => 'tech']  ]  ) );

// Search public feeds by name var response1 = await _feedsV3Client.QueryFeedsAsync(  request: new QueryFeedsRequest  {  Filter = new  {  visibility = new { __eq = "public" },  name = new { __q = "Sports" }  }  } );  // Search public feeds by description var response2 = await _feedsV3Client.QueryFeedsAsync(  request: new QueryFeedsRequest  {  Filter = new  {  visibility = "public",  description = new { __q = "tech" }  }  } );

# Search public feeds by name response1 = feeds.query_feeds(  filter={  "visibility": {"$eq": "public"},  "name": {"$q": "Sports"}  } )  # Search public feeds by description response2 = feeds.query_feeds(  filter={  "visibility": "public",  "description": {"$q": "tech"}  } )

# Search public feeds by name response1 = client.feeds.query_feeds(  GetStream::Generated::Models::QueryFeedsRequest.new(  filter: {  "visibility" => { "$eq" => "public" },  "name" => { "$q" => "Sports" }  }  ) )  # Search public feeds by description response2 = client.feeds.query_feeds(  GetStream::Generated::Models::QueryFeedsRequest.new(  filter: {  "visibility" => "public",  "description" => { "$q" => "tech" }  }  ) )

Querying feeds by creator name

let query = FeedsQuery(  filter: .and([  .equal(.visibility, "public"),  .query(.createdByName, "Thompson")  ]) ) let feedList = client.feedList(for: query) let feeds = try await feedList.get()

val query = FeedsQuery(  filter = Filters.and(  FeedsFilterField.visibility.equal("public"),  FeedsFilterField.createdByName.query("Thompson"),  ) ) val feedList = client.feedList(query = query) val feeds: Result<List<FeedData>> = feedList.get()

// search public feeds created by users with 'Thompson' in their name await client.queryFeeds({  filter: {  visibility: "public",  "created_by.name": { $q: "Thompson" },  }, });

const query = FeedsQuery(  filter: Filter.and([  Filter.equal(FeedsFilterField.visibility, 'public'),  Filter.query(FeedsFilterField.createdByName, 'Thompson'),  ]), );  final feedList = client.feedList(query); final feeds = await feedList.get();

// search public feeds created by users with 'Thompson' in their name await client.feeds.queryFeeds({  filter: {  visibility: "public",  "created_by.name": { $q: "Thompson" },  }, });

// Create context ctx := context.Background()  // Search public feeds created by users with 'Thompson' in their name if response, err := client.Feeds().QueryFeeds(ctx, &getstream.QueryFeedsRequest{  Filter: map[string]any{  "visibility": "public",  "created_by.name": map[string]any{  "$q": "Thompson",  },  }, });  err != nil {  log.Fatal("Error querying feeds:", err) } else {  log.Printf("Found %d feeds", len(response.Data.Feeds)) }

// Search public feeds created by users with 'Thompson' in their name Map<String, Object> filter = new HashMap<>(); filter.put("visibility", "public"); filter.put("created_by.name", Map.of("$q", "Thompson"));  QueryFeedsRequest request = QueryFeedsRequest.builder()  .filter(filter)  .build();  QueryFeedsResponse response = feeds.queryFeeds(request).execute().getData();

$response = $feedsClient->queryFeeds(  new GeneratedModels\QueryFeedsRequest(  filter: (object)[  'visibility' => 'public',  'created_by.name' => (object)['$q' => 'Thompson']  ]  ) );

var response = await _feedsV3Client.QueryFeedsAsync(  request: new QueryFeedsRequest  {  Filter = new  {  visibility = "public",  created_by = new { name = new { __q = "Thompson" } }  }  } );

response = feeds.query_feeds(  filter={  "visibility": "public",  "created_by.name": {"$q": "Thompson"}  } )

response = client.feeds.query_feeds(  GetStream::Generated::Models::QueryFeedsRequest.new(  filter: {  "visibility" => "public",  "created_by.name" => { "$q" => "Thompson" }  }  ) )

A complex example

Search for user feeds where text matches the feed’s name, description or creator’s name:

let query = FeedsQuery(  filter: .and([  .equal(.groupId, "user"),  .or([  .query(.name, searchQuery),  .query(.description, searchQuery),  .query(.createdByName, searchQuery)  ])  ]) ) let feedList = client.feedList(for: query) let feeds = try await feedList.get()

val query = FeedsQuery(  filter = Filters.and(  FeedsFilterField.groupId.equal("user"),  Filters.or(  FeedsFilterField.name.query(searchQuery),  FeedsFilterField.description.query(searchQuery),  FeedsFilterField.createdByName.query(searchQuery)  )  ) ) val feedList = client.feedList(query = query) val feeds: Result<List<FeedData>> = feedList.get()

await client.queryFeeds({  filter: {  group_id: "user",  $or: [  { name: { $q: searchQuery } },  { description: { $q: searchQuery } },  { "created_by.name": { $q: searchQuery } },  ],  }, });

const query = FeedsQuery(  filter: Filter.and([  Filter.equal(FeedsFilterField.groupId, 'user'),  Filter.or([  Filter.query(FeedsFilterField.name, searchQuery),  Filter.query(FeedsFilterField.description, searchQuery),  Filter.query(FeedsFilterField.createdByName, searchQuery),  ]),  ]), );  final feedList = client.feedList(query); final feeds = await feedList.get();

await client.queryFeeds({  filter: {  group_id: "user",  $or: [  { name: { $q: searchQuery } },  { description: { $q: searchQuery } },  { "created_by.name": { $q: searchQuery } },  ],  }, });

// Create context ctx := context.Background()  response, err := client.Feeds().QueryFeeds(ctx, &getstream.QueryFeedsRequest{  Filter: map[string]any{  "group_id": "user",  "$or": []map[string]any{  {"name": map[string]any{"$q": searchQuery}},  {"description": map[string]any{"$q": searchQuery}},  {"created_by.name": map[string]any{"$q": searchQuery}},  },  }, }) if err != nil {  log.Fatal("Error querying feeds:", err) } log.Printf("Query feeds response: %+v", response)

Map<String, Object> filter = new HashMap<>(); filter.put("group_id", "user"); filter.put("$or", List.of(  Map.of("name", Map.of("$q", searchQuery)),  Map.of("description", Map.of("$q", searchQuery)),  Map.of("created_by.name", Map.of("$q", searchQuery)) ));  QueryFeedsRequest request = QueryFeedsRequest.builder()  .filter(filter)  .build();  QueryFeedsResponse response = feeds.queryFeeds(request).execute().getData();

$response = $feedsClient->queryFeeds(  new GeneratedModels\QueryFeedsRequest(  filter: (object)[  'group_id' => 'user',  '$or' => [  (object)['name' => (object)['$q' => $searchQuery]],  (object)['description' => (object)['$q' => $searchQuery]],  (object)['created_by.name' => (object)['$q' => $searchQuery]]  ]  ]  ) );

var response = await _feedsV3Client.QueryFeedsAsync(  request: new QueryFeedsRequest  {  Filter = new  {  group_id = "user",  __or = new[]  {  new { name = new { __q = searchQuery } },  new { description = new { __q = searchQuery } },  new { created_by = new { email = new { __q = searchQuery } } }  }  }  } );

response = feeds.query_feeds(  filter={  "group_id": "user",  "$or": [  {"name": {"$q": search_query}},  {"description": {"$q": search_query}},  {"created_by.name": {"$q": search_query}}  ]  } )

response = client.feeds.query_feeds(  GetStream::Generated::Models::QueryFeedsRequest.new(  filter: {  "group_id" => "user",  "$or" => [  { "name" => { "$q" => search_query } },  { "description" => { "$q" => search_query } },  { "created_by.name" => { "$q" => search_query } }  ]  }  ) )

Feeds Queryable Built-in Fields

name	type	description	supported operations	example
`id`	string or list of strings	The ID of the feed	`$in`, `$eq`	`{ id: { $in: [ 'abc', 'xyz' ] } }`
`group_id`	string or list of strings	The ID of the group this feed belongs to	`$in`, `$eq`	`{ group_id: { $in: [ 'abc', 'xyz' ] } }`
`feed`	string or list of strings	The fully qualified feed ID (group_id:id)	`$in`, `$eq`	`{ fid: { $in: [ 'abc', 'xyz' ] } }`
`visibility`	string or list of strings	The visibility setting of the feed	`$in`, `$eq`	`{ visibility: { $eq: 'public' } }`
`created_by_id`	string or list of strings	The ID of the user who created the feed	`$in`, `$eq`	`{ created_by_id: { $in: [ 'abc', 'xyz' ] } }`
`created_by.name`	string	The name of the user who created the feed	`$eq`, `$q`, `$autocomplete`	`{ 'created_by.name': { $autocomplete: 'Frank' } }`
`name`	string	The name of the feed	`$eq`, `$q`, `$autocomplete`	`{ name: { $q: 'Sports' } }`
`description`	string	The description of the feed	`$eq`, `$q`, `$autocomplete`	`{ description: { $autocomplete: 'tech' } }`
`member_count`	number	The number of members in this feed	`$eq`, `$ne`, `$gt`, `$lt`, `$gte`, `$lte`	`{ member_count: { $gt: 100 } }`
`members`	list of strings	The list of members in this feed	`$in`	`{ members: { $in: [ 'bob', 'alice' ] } }`
`following_count`	number	The number of feeds this feed follows	`$eq`, `$ne`, `$gt`, `$lt`, `$gte`, `$lte`	`{ following_count: { $gt: 100 } }`
`following_feeds`	list of strings	The list of feeds this feed follows	`$in`	`{ following_feeds: { $in: [ 'feed1', 'feed2' ] } }`
`follower_count`	number	The number of followers of this feed	`$eq`, `$ne`, `$gt`, `$lt`, `$gte`, `$lte`	`{ follower_count: { $gt: 100 } }`
`created_at`	string, RFC3339 timestamp	The time the feed was created	`$eq`, `$gt`, `$lt`, `$gte`, `$lte`	`{ created_at: { $gte: '2023-12-04T09:30:20.45Z' } }`
`updated_at`	string, RFC3339 timestamp	The time the feed was updated	`$eq`, `$gt`, `$lt`, `$gte`, `$lte`	`{ updated_at: { $gte: '2023-12-04T09:30:20.45Z' } }`
`filter_tags`	list of strings	Tags for filtering the feed	`$eq`, `$contains`, `$in`	`{ filter_tags: { $in: [ 'sports', 'news' ] } }`

Filter expressions can be combined using $or and $and operators as well.

Feeds can be sorted by created_at, updated_at, member_count, follower_count, and following_count.

Be sure to reach out to support if you need additional query feed capabilities.

Feeds

Feed and Activity Visibility