# Search for Feeds

The query feeds endpoint lets you search for feeds.

## Examples

### Querying My Feeds

<Tabs>

```swift label="Swift"
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
```

```kotlin label="Kotlin"
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
```

```js label="JavaScript"
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,
});
```

```js label="React"
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,
});
```

```js label="React Native"
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,
});
```

```dart label="Dart"
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;
```

```js label="Node"
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,
});
```

```go label="Go"
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)
```

```java label="Java"
// 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();
```

```php label="php"
// 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
    )
);
```

```csharp label="C#"
// 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
    }
);
```

```python label="Python"
# 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"]
)
```

```ruby label="Ruby"
# 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
if first_page.next
  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.next
    )
  )
end
```

</Tabs>

### Querying Feeds Where I Am a Member

<Tabs>

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

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

```js label="JavaScript"
await client.queryFeeds({
  filter: {
    members: { $in: ["john"] },
  },
});
```

```js label="React"
await client.queryFeeds({
  filter: {
    members: { $in: ["john"] },
  },
});
```

```js label="React Native"
await client.queryFeeds({
  filter: {
    members: { $in: ["john"] },
  },
});
```

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

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

```go label="Go"
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)
```

```java label="Java"
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();
```

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

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

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

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

</Tabs>

### Querying feeds by name or description

<Tabs>

```swift label="Swift"
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()
```

```kotlin label="Kotlin"
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()
```

```javascript label="JavaScript"
await client.queryFeeds({
  filter: {
    visibility: { $eq: "public" },
    name: { $q: "Sports" },
  },
});

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

```javascript label="React"
await client.queryFeeds({
  filter: {
    visibility: { $eq: "public" },
    name: { $q: "Sports" },
  },
});

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

```javascript label="React Native"
await client.queryFeeds({
  filter: {
    visibility: { $eq: "public" },
    name: { $q: "Sports" },
  },
});

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

```dart label="Dart"
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();
```

```javascript label="Node"
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" },
  },
});
```

```go label="Go"
// 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",
    },
  },
})
```

```java label="Java"
// 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();
```

```php label="php"
// 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']
        ]
    )
);
```

```csharp label="C#"
// 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" }
        }
    }
);
```

```python label="Python"
# 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"}
    }
)
```

```ruby label="Ruby"
# 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" }
    }
  )
)
```

</Tabs>

### Querying feeds by creator name

<Tabs>

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

```kotlin label="Kotlin"
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()
```

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

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

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

```dart label="Dart"
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();
```

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

```go label="Go"
// 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))
}
```

```java label="Java"
// 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();
```

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

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

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

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

</Tabs>

### A complex example

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

<Tabs>

```swift label="Swift"
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()
```

```kotlin label="Kotlin"
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()
```

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

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

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

```dart label="Dart"
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();
```

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

```go label="Go"
// 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)
```

```java label="Java"
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();
```

```php label="php"
$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]]
            ]
        ]
    )
);
```

```csharp label="C#"
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 } } }
            }
        }
    }
);
```

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

```ruby label="Ruby"
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 } }
      ]
    }
  )
)
```

</Tabs>

## 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' ] } }`                                             |
| `near`            | object                    | GEO point and distance (km) to filter by  | `$eq`                                      | `{ near: { $eq: { lat: 40.0, lng: -74.0, distance: 200 } } }`                                |
| `within_bounds`   | object                    | GEO bounding box to filter by             | `$eq`                                      | `{ within_bounds: { $eq: { ne_lat: 40.0, ne_lng: -115.0, sw_lat: 32.0, sw_lng: -125.0 } } }` |

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.


---

This page was last updated at 2026-05-08T12:56:54.039Z.

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