Logs & Analytics

Stream provides APIs to query moderation logs, export them for compliance, retrieve analytics, and track usage statistics. These endpoints help you audit moderation activity, monitor moderator performance, and generate reports.

Query Moderation Logs

POST /api/v2/moderation/logs

Query moderation action logs with filtering, sorting, and pagination. Logs record every moderation action taken -- who did what, when, and on which content.

const response = await client.moderation.queryModerationLogs({
  filter: { entity_type: "stream:chat:v1:message" },
  sort: [{ field: "created_at", direction: -1 }],
  limit: 50,
});

response = client.moderation().query_moderation_logs(
    filter={"entity_type": "stream:chat:v1:message"},
    sort=[{"field": "created_at", "direction": -1}],
    limit=50,
)

response, err := client.Moderation().QueryModerationLogs(ctx, &getstream.QueryModerationLogsRequest{
    Filter: map[string]interface{}{"entity_type": "stream:chat:v1:message"},
    Sort:   []getstream.SortParam{{Field: "created_at", Direction: getstream.PtrTo(-1)}},
    Limit:  getstream.PtrTo(50),
})

client.moderation().queryModerationLogs(QueryModerationLogsRequest.builder()
    .filter(Map.of("entity_type", "stream:chat:v1:message"))
    .sort(List.of(SortParam.builder().field("created_at").direction(-1).build()))
    .limit(50)
    .build()).execute();

$response = $client->moderation()->queryModerationLogs(new QueryModerationLogsRequest(
    filter: (object)['entity_type' => 'stream:chat:v1:message'],
    sort: [new SortParam(field: 'created_at', direction: -1)],
    limit: 50,
));

response = client.moderation.query_moderation_logs(
  GetStream::Generated::Models::QueryModerationLogsRequest.new(
    filter: { "entity_type" => "stream:chat:v1:message" },
    sort: [GetStream::Generated::Models::SortParam.new(field: "created_at", direction: -1)],
    limit: 50
  )
)

var response = await client.Moderation.QueryModerationLogsAsync(new QueryModerationLogsRequest
{
    Filter = new Dictionary<string, object> { { "entity_type", "stream:chat:v1:message" } },
    Sort = new List<SortParam> { new() { Field = "created_at", Direction = -1 } },
    Limit = 50,
});

Request Parameters

Response

Export Moderation Logs

POST /api/v2/moderation/logs/export

Export moderation logs for external analysis or compliance purposes. The export can be filtered by time range, entity type, or any other supported filter condition.

const response = await client.moderation.exportModerationLogs({
  filter: { created_at: { $gte: "2024-01-01T00:00:00Z" } },
});

response = client.moderation().export_moderation_logs(
    filter={"created_at": {"$gte": "2024-01-01T00:00:00Z"}},
)

response, err := client.Moderation().ExportModerationLogs(ctx, &getstream.ExportModerationLogsRequest{
    Filter: map[string]interface{}{
        "created_at": map[string]interface{}{"$gte": "2024-01-01T00:00:00Z"},
    },
})

client.moderation().exportModerationLogs(ExportModerationLogsRequest.builder()
    .filter(Map.of("created_at", Map.of("$gte", "2024-01-01T00:00:00Z")))
    .build()).execute();

$response = $client->moderation()->exportModerationLogs(new ExportModerationLogsRequest(
    filter: (object)['created_at' => (object)['$gte' => '2024-01-01T00:00:00Z']],
));

response = client.moderation.export_moderation_logs(
  GetStream::Generated::Models::ExportModerationLogsRequest.new(
    filter: { "created_at" => { "$gte" => "2024-01-01T00:00:00Z" } }
  )
)

var response = await client.Moderation.ExportModerationLogsAsync(new ExportModerationLogsRequest
{
    Filter = new Dictionary<string, object>
    {
        { "created_at", new Dictionary<string, object> { { "$gte", "2024-01-01T00:00:00Z" } } }
    },
});

Request Parameters

Response

Get Moderation Analytics

POST /api/v2/moderation/analytics

Retrieve moderation analytics for a specified time range. This is a server-side only endpoint that returns aggregate statistics about moderation activity.

const response = await client.moderation.getModerationAnalytics({
  from: "2024-01-01T00:00:00Z",
  to: "2024-01-31T23:59:59Z",
});

response = client.moderation().get_moderation_analytics(
    from_="2024-01-01T00:00:00Z",
    to="2024-01-31T23:59:59Z",
)

response, err := client.Moderation().GetModerationAnalytics(ctx, &getstream.GetModerationAnalyticsRequest{
    From: getstream.PtrTo("2024-01-01T00:00:00Z"),
    To:   getstream.PtrTo("2024-01-31T23:59:59Z"),
})

client.moderation().getModerationAnalytics(GetModerationAnalyticsRequest.builder()
    .from("2024-01-01T00:00:00Z")
    .to("2024-01-31T23:59:59Z")
    .build()).execute();

$response = $client->moderation()->getModerationAnalytics(new GetModerationAnalyticsRequest(
    from: '2024-01-01T00:00:00Z',
    to: '2024-01-31T23:59:59Z',
));

response = client.moderation.get_moderation_analytics(
  GetStream::Generated::Models::GetModerationAnalyticsRequest.new(
    from: "2024-01-01T00:00:00Z",
    to: "2024-01-31T23:59:59Z"
  )
)

var response = await client.Moderation.GetModerationAnalyticsAsync(new GetModerationAnalyticsRequest
{
    From = "2024-01-01T00:00:00Z",
    To = "2024-01-31T23:59:59Z",
});

Request Parameters

Response

Query Usage Stats

POST /api/v2/moderation/usage_stats

Query moderation usage statistics -- number of checks, flags, actions, and other operational metrics over a given time period.

const response = await client.moderation.queryUsageStats({
  from: "2024-01-01T00:00:00Z",
  to: "2024-01-31T23:59:59Z",
});

response = client.moderation().query_usage_stats(
    from_="2024-01-01T00:00:00Z",
    to="2024-01-31T23:59:59Z",
)

response, err := client.Moderation().QueryUsageStats(ctx, &getstream.QueryUsageStatsRequest{
    From: getstream.PtrTo("2024-01-01T00:00:00Z"),
    To:   getstream.PtrTo("2024-01-31T23:59:59Z"),
})

client.moderation().queryUsageStats(QueryUsageStatsRequest.builder()
    .from("2024-01-01T00:00:00Z")
    .to("2024-01-31T23:59:59Z")
    .build()).execute();

$response = $client->moderation()->queryUsageStats(new QueryUsageStatsRequest(
    from: '2024-01-01T00:00:00Z',
    to: '2024-01-31T23:59:59Z',
));

response = client.moderation.query_usage_stats(
  GetStream::Generated::Models::QueryUsageStatsRequest.new(
    from: "2024-01-01T00:00:00Z",
    to: "2024-01-31T23:59:59Z"
  )
)

var response = await client.Moderation.QueryUsageStatsAsync(new QueryUsageStatsRequest
{
    From = "2024-01-01T00:00:00Z",
    To = "2024-01-31T23:59:59Z",
});

Request Parameters

Response

Get User Moderation Report

GET /api/v2/moderation/user_report

Retrieve a comprehensive moderation report for a specific user, including moderation history, flags received, and actions taken against their content.

const response = await client.moderation.getUserModerationReport({
  user_id: "user_123",
});

response = client.moderation().get_user_moderation_report(
    user_id="user_123",
)

response, err := client.Moderation().GetUserModerationReport(ctx, &getstream.GetUserModerationReportRequest{
    UserID: "user_123",
})

client.moderation().getUserModerationReport(GetUserModerationReportRequest.builder()
    .userId("user_123")
    .build()).execute();

$response = $client->moderation()->getUserModerationReport(new GetUserModerationReportRequest(
    userId: 'user_123',
));

response = client.moderation.get_user_moderation_report(
  GetStream::Generated::Models::GetUserModerationReportRequest.new(
    user_id: "user_123"
  )
)

var response = await client.Moderation.GetUserModerationReportAsync(new GetUserModerationReportRequest
{
    UserId = "user_123",
});

Request Parameters

Response

Get Flag Count

POST /api/v2/moderation/flag_count

Get the number of moderation flags created against a specific user's content. Useful for building moderation dashboards and identifying repeat offenders.

const response = await client.moderation.getFlagCount({
  user_id: "user_123",
});

response = client.moderation().get_flag_count(
    user_id="user_123",
)

response, err := client.Moderation().GetFlagCount(ctx, &getstream.GetFlagCountRequest{
    UserID: "user_123",
})

client.moderation().getFlagCount(GetFlagCountRequest.builder()
    .userId("user_123")
    .build()).execute();

$response = $client->moderation()->getFlagCount(new GetFlagCountRequest(
    userId: 'user_123',
));

response = client.moderation.get_flag_count(
  GetStream::Generated::Models::GetFlagCountRequest.new(
    user_id: "user_123"
  )
)

var response = await client.Moderation.GetFlagCountAsync(new GetFlagCountRequest
{
    UserId = "user_123",
});

Request Parameters

Response