# Search for Activities
## Scope
### When called from client-side
`queryActivities` endpoint searches for activities in `public` and `visible` feeds. It also respects activity visibility:
- `private` activities are only returned for the activity author
- if an activity has `tag` visibilty, and user doesn't have access to the full activity, only a preview is returned (for text based searches the search is performed across the whole activity text, not just the preview)
### When called from server-side
`queryActivities` endpoint searches for activities in all feeds, regardless of visibility. It also respects activity visibility:
- `private` activities are not returned, unless `include_private_activities` is set to `true` [see example below](#querying-private-activities))
- activities with `tag` visibility are returned with full content, not just a preview
- `user_id` can be passed to turn a server-side request into a client-side request [see example below](#user_id-for-server-side-requests)
## Examples
You can query & search activities. Here's an example of how to query activities:
```swift
let query = ActivitiesQuery(
filter: .equal(.type, "post"),
sort: [Sort(field: .createdAt, direction: .reverse)],
limit: 10
)
let activityList = client.activityList(for: query)
let activities = try await activityList.get()
```
```kotlin
val query = ActivitiesQuery(
filter = ActivitiesFilterField.type.equal("post"),
sort = listOf(ActivitiesSort(ActivitiesSortField.CreatedAt, SortDirection.REVERSE)),
limit = 10
)
val activityList = client.activityList(query = query)
val activities: Result> = activityList.get()
```
```js
client.queryActivities({
filter: {
activity_type: "post",
},
sort: [{ field: "created_at", direction: -1 }],
limit: 10,
});
```
```js
client.queryActivities({
filter: {
activity_type: "post",
},
sort: [{ field: "created_at", direction: -1 }],
limit: 10,
});
```
```js
client.queryActivities({
filter: {
activity_type: "post",
},
sort: [{ field: "created_at", direction: -1 }],
limit: 10,
});
```
```js
client.feeds.queryActivities({
filter: {
activity_type: "post",
},
sort: [{ field: "created_at", direction: -1 }],
limit: 10,
});
```
```dart
final query = ActivitiesQuery(
filter: const Filter.equal(ActivitiesFilterField.type, 'post'),
sort: [ActivitiesSort.desc(ActivitiesSortField.createdAt)],
limit: 10,
);
final activityList = client.activityList(query);
final activities = await activityList.get();
```
```go
response, err := client.Feeds().QueryActivities(context.Background(), &getstream.QueryActivitiesRequest{
Filter: map[string]any{
"activity_type": "post",
},
Sort: []getstream.SortParamRequest{
{
Field: stringPtr("created_at"),
Direction: intPtr(-1),
},
},
Limit: intPtr(10),
})
```
```java
Map filter = new HashMap<>();
filter.put("activity_type", "post");
QueryActivitiesRequest request =
QueryActivitiesRequest.builder().limit(10).filter(filter).build();
QueryActivitiesResponse response = feeds.queryActivities(request).execute().getData();
```
```php
$response = $feedsClient->queryActivities(
new GeneratedModels\QueryActivitiesRequest(
limit: 10,
filter: (object)['activity_type' => 'post'],
sort: [['field' => 'created_at', 'direction' => -1]]
)
);
```
```csharp
var response = await _feedsV3Client.QueryActivitiesAsync(
new QueryActivitiesRequest
{
Limit = 10,
Filter = new Dictionary { ["activity_type"] = "post" }
}
);
```
```python
response = self.client.feeds.query_activities(
limit=10, filter={"activity_type": "post"}
)
```
```ruby
require 'getstream_ruby'
client = GetStreamRuby.manual(
api_key: 'api_key',
api_secret: 'api_secret'
)
# First page query
first_page = client.feeds.query_activities(
GetStream::Generated::Models::QueryActivitiesRequest.new(
limit: 10,
filter: { activity_type: 'post' },
sort: [{ field: 'created_at', direction: -1 }]
)
)
# Second page using next cursor from first page
if first_page.next
second_page = client.feeds.query_activities(
GetStream::Generated::Models::QueryActivitiesRequest.new(
limit: 10,
filter: { activity_type: 'post' },
sort: [{ field: 'created_at', direction: -1 }],
next: first_page.next
)
)
end
```
When searching activities, the `activity.current_feed` field contains information about the feed the activity belongs to. However, if an activity is posted to multiple feeds, this field will be empty. In this case, you can use the `activity.feeds` array to read all feed IDs the activity was posted to and fetch feeds separately if needed.
Search filter syntax emulates a MongoDB style query syntax. (It emulates it, we don't use MongoDB, but the query syntax is nice here).
### Querying activities by text
```swift
// search for activities where the text includes the word 'popularity'.
let query = ActivitiesQuery(
filter: .query(.text, "popularity")
)
let activityList = client.activityList(for: query)
let activities = try await activityList.get()
```
```kotlin
// search for activities where the text includes the word 'popularity'.
val query = ActivitiesQuery(
filter = ActivitiesFilterField.text.query("popularity")
)
val activityList = client.activityList(query = query)
val activities: Result> = activityList.get()
```
```js
client.queryActivities({
filter: {
text: {
$q: "popularity",
},
},
});
```
```js
client.queryActivities({
filter: {
text: {
$q: "popularity",
},
},
});
```
```js
client.queryActivities({
filter: {
text: {
$q: "popularity",
},
},
});
```
```js
client.feeds.queryActivities({
filter: {
text: {
$q: "popularity",
},
},
});
```
```dart
// search for activities where the text includes the word 'popularity'.
const query = ActivitiesQuery(
filter: Filter.equal(ActivitiesFilterField.text, 'popularity'),
);
final activityList = client.activityList(query);
final activities = await activityList.get();
```
```go
response, err := client.Feeds().QueryActivities(context.Background(), &getstream.QueryActivitiesRequest{
Filter: map[string]any{
"text": map[string]any{
"$q": "popularity",
},
},
})
```
```java
Map filter = new HashMap<>();
filter.put("activity_type", "post");
QueryActivitiesRequest request =
QueryActivitiesRequest.builder().limit(10).filter(filter).build();
QueryActivitiesResponse response = feeds.queryActivities(request).execute().getData();
```
```php
// search for activities where the text includes the word 'popularity'.
$response = $feedsClient->queryActivities(
new GeneratedModels\QueryActivitiesRequest(
filter: (object)[
'text' => (object)[
'$q' => 'popularity'
]
]
)
);
```
```csharp
var response = await _feedsV3Client.QueryActivitiesAsync(
new QueryActivitiesRequest
{
Limit = 10,
Filter = new Dictionary { ["activity_type"] = "post" }
}
);
```
```python
response = self.client.feeds.query_activities(
limit=10, filter={"activity_type": "post"}
)
```
```ruby
require 'getstream_ruby'
client = GetStreamRuby.manual(
api_key: 'api_key',
api_secret: 'api_secret'
)
query_request = GetStream::Generated::Models::QueryActivitiesRequest.new(
filter: {
text: {
'$q' => 'popularity'
}
}
)
response = client.feeds.query_activities(query_request)
```
### Querying activities by search data
Consider this example activity:
```json
{
"id": "activity-123",
"type": "post",
"text": "Check out our spring sale!",
"search_data": {
"campaign": {
"id": "spring-sale-2025",
"location": {
"mall": "yorkdale",
"city": "toronto",
"country": "canada"
}
}
}
// ... other activity fields
}
```
You can search this activity using the `search_data` field in several ways:
```swift
// search for activities associated with the campaign ID 'spring-sale-2025'
let searchValue: [String: RawJSON] = ["campaign": .dictionary(["id": .string("spring-sale-2025")])]
let query = ActivitiesQuery(
filter: .contains(.searchData, searchValue)
)
let activityList = client.activityList(for: query)
let activities = try await activityList.get()
// search for activities where the campaign took place in a mall
let query2 = ActivitiesQuery(
filter: .pathExists(.searchData, "campaign.location.mall")
)
let activityList2 = client.activityList(for: query2)
let activities2 = try await activityList2.get()
```
```kotlin
// search for activities associated with the campaign ID 'spring-sale-2025'
val searchValue = mapOf("campaign" to mapOf("id" to "spring-sale-2025"))
val query = ActivitiesQuery(
filter = ActivitiesFilterField.searchData.contains(searchValue)
)
val activityList = client.activityList(query = query)
val activities: Result> = activityList.get()
// search for activities where the campaign took place in a mall
val query2 = ActivitiesQuery(
filter = ActivitiesFilterField.searchData.pathExists("campaign.location.mall")
)
val activityList2 = client.activityList(query = query2)
val activities2: Result> = activityList2.get()
```
```js
client.queryActivities({
filter: {
search_data: { $contains: { campaign: { id: "spring-sale-2025" } } },
},
});
client.queryActivities({
filter: {
search_data: { $path_exists: "campaign.location.mall" },
},
});
```
```js
client.queryActivities({
filter: {
search_data: { $contains: { campaign: { id: "spring-sale-2025" } } },
},
});
client.queryActivities({
filter: {
search_data: { $path_exists: "campaign.location.mall" },
},
});
```
```js
client.queryActivities({
filter: {
search_data: { $contains: { campaign: { id: "spring-sale-2025" } } },
},
});
client.queryActivities({
filter: {
search_data: { $path_exists: "campaign.location.mall" },
},
});
```
```js
client.feeds.queryActivities({
filter: {
search_data: { $contains: { campaign: { id: "spring-sale-2025" } } },
},
});
client.feeds.queryActivities({
filter: {
search_data: { $path_exists: "campaign.location.mall" },
},
});
```
```dart
// search for activities associated with the campaign ID 'spring-sale-2025'
final searchValue = {
'campaign': {'id': 'spring-sale-2025'},
};
final query = ActivitiesQuery(
filter: Filter.contains(ActivitiesFilterField.searchData, searchValue),
);
final activityList = client.activityList(query);
final activities = await activityList.get();
// search for activities where the campaign took place in a mall
const query2 = ActivitiesQuery(
filter: Filter.pathExists(
ActivitiesFilterField.searchData,
'campaign.location.mall',
),
);
final activityList2 = client.activityList(query2);
final activities2 = await activityList2.get();
```
```go
query1 := &getstream.QueryActivitiesRequest{
Filter: map[string]any{
"search_data": map[string]any{
"$contains": map[string]any{
"campaign": map[string]any{
"id": "spring-sale-2025",
},
},
},
},
}
response1, err := client.Feeds().QueryActivities(context.Background(), query1)
query2 := &getstream.QueryActivitiesRequest{
Filter: map[string]any{
"search_data": map[string]any{
"$path_exists": "campaign.location.mall",
},
},
}
response2, err := client.Feeds().QueryActivities(context.Background(), query2)
```
```java
Map filter = new HashMap<>();
filter.put("activity_type", "post");
QueryActivitiesRequest request =
QueryActivitiesRequest.builder().limit(10).filter(filter).build();
QueryActivitiesResponse response = feeds.queryActivities(request).execute().getData();
```
```php
// search for activities associated with the campaign ID 'spring-sale-2025'
$response = $feedsClient->queryActivities(
new GeneratedModels\QueryActivitiesRequest(
filter: (object)[
'search_data' => (object)[
'$contains' => (object)[
'campaign' => (object)[
'id' => 'spring-sale-2025'
]
]
]
]
)
);
// search for activities where the campaign took place in a mall
$response2 = $feedsClient->queryActivities(
new GeneratedModels\QueryActivitiesRequest(
filter: (object)[
'search_data' => (object)[
'$path_exists' => 'campaign.location.mall'
]
]
)
);
```
```csharp
var response = await _feedsV3Client.QueryActivitiesAsync(
new QueryActivitiesRequest
{
Limit = 10,
Filter = new Dictionary { ["activity_type"] = "post" }
}
);
```
```python
response = self.client.feeds.query_activities(
limit=10, filter={"activity_type": "post"}
)
```
```ruby
require 'getstream_ruby'
client = GetStreamRuby.manual(
api_key: 'api_key',
api_secret: 'api_secret'
)
# search for activities associated with the campaign ID 'spring-sale-2025'
query_request = GetStream::Generated::Models::QueryActivitiesRequest.new(
filter: {
search_data: {
'$contains' => {
campaign: {
id: 'spring-sale-2025'
}
}
}
}
)
response = client.feeds.query_activities(query_request)
# search for activities where the campaign took place in a mall
query_request2 = GetStream::Generated::Models::QueryActivitiesRequest.new(
filter: {
search_data: {
'$path_exists' => 'campaign.location.mall'
}
}
)
response2 = client.feeds.query_activities(query_request2)
```
### Querying private activities
For server-side requests, you can set `include_private_activities` to `true` to include private activities in the results (the default is `false`).
```js
const response = await client.feeds.queryActivities({
include_private_activities: true,
filter: {
// your filter here
},
});
```
```go
response, err := client.Feeds().QueryActivities(context.Background(), &getstream.QueryActivitiesRequest{
IncludePrivateActivities: boolPtr(true),
Filter: map[string]any{
// your filter here
},
})
```
```java
Map filter = new HashMap<>();
// your filter here
QueryActivitiesRequest request = QueryActivitiesRequest.builder()
.filter(filter)
.includePrivateActivities(true)
.build();
QueryActivitiesResponse response = feeds.queryActivities(request).execute().getData();
```
```php
$response = $feedsClient->queryActivities(
new GeneratedModels\QueryActivitiesRequest(
include_private_activities: true,
filter: (object)[
// your filter here
]
)
);
```
```csharp
var response = await _feedsV3Client.QueryActivitiesAsync(
new QueryActivitiesRequest
{
IncludePrivateActivities = true,
Filter = new Dictionary {
// your filter here
}
}
);
```
```python
response = self.client.feeds.query_activities(
include_private_activities=True,
filter={
# your filter here
}
)
```
```ruby
require 'getstream_ruby'
client = GetStreamRuby.manual(
api_key: 'api_key',
api_secret: 'api_secret'
)
query_request = GetStream::Generated::Models::QueryActivitiesRequest.new(
include_private_activities: true,
filter: {
# your filter here
}
)
response = client.feeds.query_activities(query_request)
```
### `user_id` for server-side requests
For server-side requests, you can provide a `user_id` to perform the search as if it were made by that specific user. It turns the server-side request into a client-side request.
```js
const response = await client.feeds.queryActivities({
user_id: "john",
filter: {
// your filter here
},
});
```
```go
response, err := client.Feeds().QueryActivities(context.Background(), &getstream.QueryActivitiesRequest{
UserID: strPtr("john"),
Filter: map[string]any{
// your filter here
},
})
```
```java
Map filter = new HashMap<>();
// your filter here
QueryActivitiesRequest request = QueryActivitiesRequest.builder()
.filter(filter)
.userId("john")
.build();
QueryActivitiesResponse response = feeds.queryActivities(request).execute().getData();
```
```php
$response = $feedsClient->queryActivities(
new GeneratedModels\QueryActivitiesRequest(
user_id: 'john',
filter: (object)[
// your filter here
]
)
);
```
```csharp
var response = await _feedsV3Client.QueryActivitiesAsync(
new QueryActivitiesRequest
{
UserId = "john",
Filter = new Dictionary {
// your filter here
}
}
);
```
```python
response = self.client.feeds.query_activities(
user_id="john",
filter={
# your filter here
}
)
```
```ruby
require 'getstream_ruby'
client = GetStreamRuby.manual(
api_key: 'api_key',
api_secret: 'api_secret'
)
query_request = GetStream::Generated::Models::QueryActivitiesRequest.new(
user_id: 'john',
filter: {
# your filter here
}
)
response = client.feeds.query_activities(query_request)
```
## Activities Queryable Built-In Fields
Be sure to reach out to support if you need additional query activity capabilities.
## Activities sort options
---
This page was last updated at 2026-03-04T14:19:09.912Z.
For the most recent version of this documentation, visit [https://getstream.io/activity-feeds/docs/javascript/query-activities/](https://getstream.io/activity-feeds/docs/javascript/query-activities/).