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 public and visible feeds. It also respects activity visibility:

• private activities are not returned, unless include_private_activities is set to true see example below)
• 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

Examples

You can query & search activities. Here’s an example of how to query activities:

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()

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<List<ActivityData>> = activityList.get()

client.queryActivities({
  filter: {
    activity_type: "post",
  },
  sort: [{ field: "created_at", direction: -1 }],
  limit: 10,
});

client.feeds.queryActivities({
  filter: {
    activity_type: "post",
  },
  sort: [{ field: "created_at", direction: -1 }],
  limit: 10,
});

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();

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),
})

Map<String, Object> filter = new HashMap<>();
filter.put("activity_type", "post");

QueryActivitiesRequest request =
    QueryActivitiesRequest.builder().limit(10).filter(filter).build();

QueryActivitiesResponse response = feeds.queryActivities(request).execute().getData();

$response = $feedsClient->queryActivities(
    new GeneratedModels\QueryActivitiesRequest(
        limit: 10,
        filter: (object)['activity_type' => 'post'],
        sort: [['field' => 'created_at', 'direction' => -1]]
    )
);

var response = await _feedsV3Client.QueryActivitiesAsync(
    new QueryActivitiesRequest
    {
        Limit = 10,
        Filter = new Dictionary<string, object> { ["activity_type"] = "post" }
    }
);

response = self.client.feeds.query_activities(
    limit=10, filter={"activity_type": "post"}
)

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

// 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()

// 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<List<ActivityData>> = activityList.get()

client.queryActivities({
  filter: {
    text: {
      $q: "popularity",
    },
  },
});

client.feeds.queryActivities({
  filter: {
    text: {
      $q: "popularity",
    },
  },
});

// 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();

response, err := client.Feeds().QueryActivities(context.Background(), &getstream.QueryActivitiesRequest{
  Filter: map[string]interface{}{
    "text": map[string]interface{}{
      "$q": "popularity",
    },
  },
})

Map<String, Object> filter = new HashMap<>();
filter.put("activity_type", "post");

QueryActivitiesRequest request =
    QueryActivitiesRequest.builder().limit(10).filter(filter).build();

QueryActivitiesResponse response = feeds.queryActivities(request).execute().getData();

// search for activities where the text includes the word 'popularity'.
$response = $feedsClient->queryActivities(
    new GeneratedModels\QueryActivitiesRequest(
        filter: (object)[
            'text' => (object)[
                '$q' => 'popularity'
            ]
        ]
    )
);

var response = await _feedsV3Client.QueryActivitiesAsync(
    new QueryActivitiesRequest
    {
        Limit = 10,
        Filter = new Dictionary<string, object> { ["activity_type"] = "post" }
    }
);

response = self.client.feeds.query_activities(
    limit=10, filter={"activity_type": "post"}
)

Querying activities by search data

Consider this example activity:

{
  "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:

// 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()

// 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<List<ActivityData>> = 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<List<ActivityData>> = activityList2.get()

client.queryActivities({
  filter: {
    search_data: { $contains: { campaign: { id: "spring-sale-2025" } } },
  },
});

client.queryActivities({
  filter: {
    search_data: { $path_exists: "campaign.location.mall" },
  },
});

client.feeds.queryActivities({
  filter: {
    search_data: { $contains: { campaign: { id: "spring-sale-2025" } } },
  },
});

client.feeds.queryActivities({
  filter: {
    search_data: { $path_exists: "campaign.location.mall" },
  },
});

// 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();

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)

Map<String, Object> filter = new HashMap<>();
filter.put("activity_type", "post");

QueryActivitiesRequest request =
    QueryActivitiesRequest.builder().limit(10).filter(filter).build();

QueryActivitiesResponse response = feeds.queryActivities(request).execute().getData();

// 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'
            ]
        ]
    )
);

var response = await _feedsV3Client.QueryActivitiesAsync(
    new QueryActivitiesRequest
    {
        Limit = 10,
        Filter = new Dictionary<string, object> { ["activity_type"] = "post" }
    }
);

response = self.client.feeds.query_activities(
    limit=10, filter={"activity_type": "post"}
)

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).

const response = await client.feeds.queryActivities({
  include_private_activities: true,
  filter: {
    // your filter here
  },
});

response, err := client.Feeds().QueryActivities(context.Background(), &getstream.QueryActivitiesRequest{
  IncludePrivateActivities: boolPtr(true),
  Filter: map[string]any{
    // your filter here
  },
})

Map<String, Object> filter = new HashMap<>();
// your filter here

QueryActivitiesRequest request = QueryActivitiesRequest.builder()
    .filter(filter)
    .includePrivateActivities(true)
    .build();

QueryActivitiesResponse response = feeds.queryActivities(request).execute().getData();

$response = $feedsClient->queryActivities(
    new GeneratedModels\QueryActivitiesRequest(
        include_private_activities: true,
        filter: (object)[
            // your filter here
        ]
    )
);

var response = await _feedsV3Client.QueryActivitiesAsync(
    new QueryActivitiesRequest
    {
        IncludePrivateActivities = true,
        Filter = new Dictionary<string, object> {
            // your filter here
        }
    }
);

response = self.client.feeds.query_activities(
    include_private_activities=True,
    filter={
        # your filter here
    }
)

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.

const response = await client.feeds.queryActivities({
  user_id: "john",
  filter: {
    // your filter here
  },
});

response, err := client.Feeds().QueryActivities(context.Background(), &getstream.QueryActivitiesRequest{
  UserID: strPtr("john"),
  Filter: map[string]any{
    // your filter here
  },
})

Map<String, Object> filter = new HashMap<>();
// your filter here

QueryActivitiesRequest request = QueryActivitiesRequest.builder()
    .filter(filter)
    .userId("john")
    .build();

QueryActivitiesResponse response = feeds.queryActivities(request).execute().getData();

$response = $feedsClient->queryActivities(
    new GeneratedModels\QueryActivitiesRequest(
        user_id: 'john',
        filter: (object)[
            // your filter here
        ]
    )
);

var response = await _feedsV3Client.QueryActivitiesAsync(
    new QueryActivitiesRequest
    {
        UserId = "john",
        Filter = new Dictionary<string, object> {
            // your filter here
        }
    }
);

response = self.client.feeds.query_activities(
    user_id="john",
    filter={
        # your filter here
    }
)

Activities Queryable Built-In Fields

The filter syntax also supports $or and $and:

// Get all the activities where filter tags contain both "green" and "orange"
let filter = .and([
  .in(.filterTags, ["green"]),
  .in(.filterTags, ["orange"])
])

// Get all the activities where filter tags contain both "green" and "orange"
val filter = Filters.and(
  ActivitiesFilterField.filterTags.`in`("green"),
  ActivitiesFilterField.filterTags.`in`("orange"),
)

// Get all the activities where filter tags contain both "green" and "orange"
const filter = {
  $and: [{ filter_tags: ["green"] }, { filter_tags: ["orange"] }],
};

// Get all the activities where filter tags contain both "green" and "orange"
const filter = Filter.and([
  Filter.in_(ActivitiesFilterField.filterTags, ['green']),
  Filter.in_(ActivitiesFilterField.filterTags, ['orange']),
])

// Get all the activities where filter tags contain both "green" and "orange"
const filter = {
  $and: [
    { filter_tags: ["green"] }
    { filter_tags: ["orange"] }
  ],
}

// Get all the activities where filter tags contain both "green" and "orange"
filter := map[string]any{
  "$and": []map[string]any{
    {"filter_tags": []string{"green"}},
    {"filter_tags": []string{"orange"}},
  },
}

// Get all the activities where filter tags contain both "green" and "orange"
Map<String, Object> filter = new HashMap<>();
List<Map<String, Object>> andConditions = List.of(
    Map.of("filter_tags", List.of("green")),
    Map.of("filter_tags", List.of("orange"))
);
filter.put("$and", andConditions);

$filter = (object)['and' => [
  'filter_tags' => ['green'],
  'filter_tags' => ['orange'],
]]

// Get all the activities where filter tags contain both "green" and "orange"
var filter = = new
{
  and = new[]
  {
    new { filter_tags = new[] { "green" } },
    new { filter_tags = new[] { "orange" } }
  }
}

# Get all the activities where filter tags contain both "green" and "orange"
filter = {
  "$and": [
    {"filter_tags": ["green"]},
    {"filter_tags": ["orange"]}
  ]
}

# Get all the activities where filter tags contain both "green" and "orange"
filter = {
  "$and" => [
    { "filter_tags" => ["green"] },
    { "filter_tags" => ["orange"] }
  ]
}

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

Activities sort options

Fields:

• created_at
• popularity

Direction: 1 or -1