--- title: Compute a retention grid description: Datadog, the leading service for cloud-scale monitoring. breadcrumbs: Docs > API Reference > Product Analytics --- > For the complete documentation index, see [llms.txt](https://docs.datadoghq.com/llms.txt). # Compute a retention grid{% #compute-a-retention-grid %} Copy pageCopied {% tab title="v2" %} **Note**: This endpoint is in preview and is subject to change. If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/). | Datadog site | API endpoint | | ----------------- | -------------------------------------------------------------------------- | | ap1.datadoghq.com | POST https://api.ap1.datadoghq.com/api/v2/product-analytics/retention/grid | | ap2.datadoghq.com | POST https://api.ap2.datadoghq.com/api/v2/product-analytics/retention/grid | | app.datadoghq.eu | POST https://api.datadoghq.eu/api/v2/product-analytics/retention/grid | | app.ddog-gov.com | POST https://api.ddog-gov.com/api/v2/product-analytics/retention/grid | | us2.ddog-gov.com | POST https://api.us2.ddog-gov.com/api/v2/product-analytics/retention/grid | | uk1.datadoghq.com | POST https://api.uk1.datadoghq.com/api/v2/product-analytics/retention/grid | | app.datadoghq.com | POST https://api.datadoghq.com/api/v2/product-analytics/retention/grid | | us3.datadoghq.com | POST https://api.us3.datadoghq.com/api/v2/product-analytics/retention/grid | | us5.datadoghq.com | POST https://api.us5.datadoghq.com/api/v2/product-analytics/retention/grid | ### Overview Compute a retention grid, showing how much of each cohort came back over each subsequent period. Rows are cohorts, columns are return periods, and each cell holds the count and rate of entities that returned. This endpoint requires the `rum_apps_read` permission. ### Request #### Body Data (required) The retention grid query. {% tab title="Model" %} | Parent field | Field | Type | Description | | ------------------------------------------ | ------------------------------------------ | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | | data [*required*] | object | The single JSON:API resource carrying a retention grid query. Its attributes hold the time window to query and the cohort and return criteria that define the grid. | | data | attributes [*required*] | object | Attributes of a retention grid request. | | attributes | exclude_anonymous_traffic | boolean | Whether to exclude sessions that are not tied to an identified user. | | attributes | from [*required*] | int64 | Start of the query window, in epoch milliseconds. | | attributes | query [*required*] | object | Query definition for a retention grid or retention metadata request. | | query | computation_scope | | Restricts a retention query to part of the grid, so that results can be examined in detail. Omit it to compute the whole grid. | | computation_scope | | object | Narrows a retention query to a single cohort row. | | | target [*required*] | | Selects a cohort, either by index or by the aggregation that rolls all cohorts together. | | target | | object | Selects a cohort or return period by its zero-based position in the grid. | | | type [*required*] | enum | The discriminator identifying a target selected by index. Allowed enum values: `index` | | | value [*required*] | int64 | Zero-based index of the targeted cohort or return period. | | target | | object | Selects the rolled-up row that aggregates every cohort, rather than a single cohort. | | | type [*required*] | enum | The discriminator identifying a target selected by aggregation. Allowed enum values: `aggregation` | | | value [*required*] | string | The aggregation that produced the rolled-up row. | | | type [*required*] | enum | The discriminator identifying a scope narrowed to one cohort. Allowed enum values: `cohort` | | computation_scope | | object | Narrows a retention query to a single return-period column. | | | target [*required*] | object | Selects a cohort or return period by its zero-based position in the grid. | | target | type [*required*] | enum | The discriminator identifying a target selected by index. Allowed enum values: `index` | | target | value [*required*] | int64 | Zero-based index of the targeted cohort or return period. | | | type [*required*] | enum | The discriminator identifying a scope narrowed to one return period. Allowed enum values: `return_period` | | computation_scope | | object | Narrows a retention query to a single cell, at the intersection of one cohort and one return period. | | | cohort_target [*required*] | | Selects a cohort, either by index or by the aggregation that rolls all cohorts together. | | cohort_target | | object | Selects a cohort or return period by its zero-based position in the grid. | | | type [*required*] | enum | The discriminator identifying a target selected by index. Allowed enum values: `index` | | | value [*required*] | int64 | Zero-based index of the targeted cohort or return period. | | cohort_target | | object | Selects the rolled-up row that aggregates every cohort, rather than a single cohort. | | | type [*required*] | enum | The discriminator identifying a target selected by aggregation. Allowed enum values: `aggregation` | | | value [*required*] | string | The aggregation that produced the rolled-up row. | | | return_period_target [*required*] | object | Selects a cohort or return period by its zero-based position in the grid. | | return_period_target | type [*required*] | enum | The discriminator identifying a target selected by index. Allowed enum values: `index` | | return_period_target | value [*required*] | int64 | Zero-based index of the targeted cohort or return period. | | | type [*required*] | enum | The discriminator identifying a scope narrowed to one grid cell. Allowed enum values: `cell` | | query | compute [*required*] | object | The metric and aggregation applied to a retention query. | | compute | aggregation [*required*] | string | The aggregation function applied to the metric, such as `count` or `avg`. | | compute | metric [*required*] | enum | The retention metric to compute, either an absolute count or a rate. Allowed enum values: `__dd.retention,__dd.retention_rate` | | query | group_by | [object] | Splits the results by the values of one or more facets. | | group_by | facet [*required*] | string | The attribute path to group by. | | group_by | limit | int64 | Maximum number of groups to return. Omit it to let the service choose. | | group_by | should_exclude_missing | boolean | Whether to drop entities that have no value for the facet. | | group_by | sort | object | Sort configuration for group-by results. | | sort | aggregation | string | The aggregation function to sort by. | | sort | metric | string | The metric to sort by. | | sort | order | enum | Direction of sort. Allowed enum values: `asc,desc` | | group_by | source | string | Audience source backing the group-by, when grouping by an audience rather than a facet. | | group_by | target [*required*] | enum | Which axis of the retention grid a group-by applies to. Allowed enum values: `cohort,return_period` | | query | search [*required*] | object | Defines the cohort and return criteria that make up a retention query. | | search | cohort_criteria [*required*] | object | Defines the event that places an entity into a cohort, and how cohorts are bucketed over time. | | cohort_criteria | base_query [*required*] | | A query definition discriminated by the `data_source` field. Use `product_analytics` for standard event queries, or `product_analytics_occurrence` for occurrence-filtered queries. | | base_query | | object | A standard Product Analytics event query. | | | data_source [*required*] | enum | The data source identifier. Allowed enum values: `product_analytics` | | | search [*required*] | object | Search parameters for an event query. | | search | query | string | The search query using Datadog search syntax. | | base_query | | object | A Product Analytics occurrence-filtered query. | | | data_source [*required*] | enum | The data source identifier for occurrence queries. Allowed enum values: `product_analytics_occurrence` | | | search [*required*] | object | Search parameters for an occurrence query. | | search | occurrences | object | Filter for occurrence-based queries. | | occurrences | meta | object | Additional metadata. | | additionalProperties | | string | | occurrences | operator [*required*] | string | Comparison operator (=, >=, <=, >, <). | | occurrences | value [*required*] | string | The occurrence count threshold as a string. | | search | query | string | The search query using Datadog search syntax. | | cohort_criteria | time_interval [*required*] | | A retention interval, either aligned to calendar boundaries or of a fixed length. Cohort criteria use calendar intervals; return criteria use fixed intervals. | | time_interval | | object | A retention interval aligned to calendar boundaries. | | | type [*required*] | enum | The discriminator identifying a calendar-aligned retention interval. Allowed enum values: `calendar` | | | value [*required*] | object | A calendar-aligned bucket definition, such as "every 1 week starting on Monday". | | value | alignment | string | Where each bucket starts within the calendar unit. Use an hour for `day` (for example `1am` or `14`), a day name for `week` (for example `monday`), or an ordinal for `month` (for example `1st`). | | value | quantity | int64 | Number of calendar units per bucket. | | value | timezone | string | Timezone used to align the buckets. | | value | type [*required*] | enum | Calendar unit used to bucket cohorts. Allowed enum values: `minute,hour,day,week,month,quarter,year` | | time_interval | | object | A retention interval of fixed length, such as "7 days". | | | type [*required*] | enum | The discriminator identifying a fixed-length retention interval. Allowed enum values: `fixed` | | | unit [*required*] | enum | Time unit for a fixed-length retention interval. Allowed enum values: `day,week,month` | | | value [*required*] | double | Length of the interval, expressed in `unit`. | | search | filters | object | Filters narrowing the events considered by a retention query. | | filters | audience_filters | object | Audience filter definitions for targeting specific user segments. | | audience_filters | accounts | [object] | Account audience queries. | | accounts | name [*required*] | string | Name of this query, referenced in the formula. | | accounts | query | string | Search query for filtering accounts. | | audience_filters | formula | string | Boolean formula combining audience queries by name. | | audience_filters | segments | [object] | Segment audience queries. | | segments | name [*required*] | string | Name of this query, referenced in the formula. | | segments | segment_id [*required*] | uuid | UUID of the segment to filter by. | | audience_filters | users | [object] | User audience queries. | | users | name [*required*] | string | Name of this query, referenced in the formula. | | users | query | string | Search query for filtering users. | | filters | string_filter | string | Free-text search query applied to the events. | | search | retention_entity [*required*] | enum | The entity whose retention is measured. Allowed enum values: `@usr.id,@account.id` | | search | return_condition [*required*] | enum | When an entity counts as having returned. Use `conversion_on` to count only entities that returned during the period itself, or `conversion_on_or_after` to also count later returns. Allowed enum values: `conversion_on,conversion_on_or_after` | | search | return_criteria | object | Defines the event that counts as a return, and the window in which it must occur. | | return_criteria | base_query [*required*] | | A query definition discriminated by the `data_source` field. Use `product_analytics` for standard event queries, or `product_analytics_occurrence` for occurrence-filtered queries. | | base_query | | object | A standard Product Analytics event query. | | | data_source [*required*] | enum | The data source identifier. Allowed enum values: `product_analytics` | | | search [*required*] | object | Search parameters for an event query. | | search | query | string | The search query using Datadog search syntax. | | base_query | | object | A Product Analytics occurrence-filtered query. | | | data_source [*required*] | enum | The data source identifier for occurrence queries. Allowed enum values: `product_analytics_occurrence` | | | search [*required*] | object | Search parameters for an occurrence query. | | search | occurrences | object | Filter for occurrence-based queries. | | occurrences | meta | object | Additional metadata. | | additionalProperties | | string | | occurrences | operator [*required*] | string | Comparison operator (=, >=, <=, >, <). | | occurrences | value [*required*] | string | The occurrence count threshold as a string. | | search | query | string | The search query using Datadog search syntax. | | return_criteria | time_interval | | A retention interval, either aligned to calendar boundaries or of a fixed length. Cohort criteria use calendar intervals; return criteria use fixed intervals. | | time_interval | | object | A retention interval aligned to calendar boundaries. | | | type [*required*] | enum | The discriminator identifying a calendar-aligned retention interval. Allowed enum values: `calendar` | | | value [*required*] | object | A calendar-aligned bucket definition, such as "every 1 week starting on Monday". | | value | alignment | string | Where each bucket starts within the calendar unit. Use an hour for `day` (for example `1am` or `14`), a day name for `week` (for example `monday`), or an ordinal for `month` (for example `1st`). | | value | quantity | int64 | Number of calendar units per bucket. | | value | timezone | string | Timezone used to align the buckets. | | value | type [*required*] | enum | Calendar unit used to bucket cohorts. Allowed enum values: `minute,hour,day,week,month,quarter,year` | | time_interval | | object | A retention interval of fixed length, such as "7 days". | | | type [*required*] | enum | The discriminator identifying a fixed-length retention interval. Allowed enum values: `fixed` | | | unit [*required*] | enum | Time unit for a fixed-length retention interval. Allowed enum values: `day,week,month` | | | value [*required*] | double | Length of the interval, expressed in `unit`. | | attributes | to [*required*] | int64 | End of the query window, in epoch milliseconds. | | data | type [*required*] | enum | The resource type identifier for a retention grid request. Allowed enum values: `retention_grid_request` | {% /tab %} {% tab title="Example" %} ```json { "data": { "attributes": { "exclude_anonymous_traffic": false, "from": 1756425600000, "query": { "computation_scope": { "target": { "type": "index", "value": 0 }, "type": "cohort" }, "compute": { "aggregation": "count", "metric": "__dd.retention_rate" }, "group_by": [ { "facet": "@geo.country", "limit": 10, "should_exclude_missing": false, "sort": { "aggregation": "count", "metric": "string", "order": "string" }, "source": "string", "target": "cohort" } ], "search": { "cohort_criteria": { "base_query": { "data_source": "product_analytics", "search": { "query": "@type:view" } }, "time_interval": { "type": "calendar", "value": { "alignment": "monday", "quantity": 1, "timezone": "UTC", "type": "week" } } }, "filters": { "audience_filters": { "accounts": [ { "name": "", "query": "string" } ], "formula": "u", "segments": [ { "name": "", "segment_id": "00000000-0000-0000-0000-000000000000" } ], "users": [ { "name": "u", "query": "*" } ] }, "string_filter": "string" }, "retention_entity": "@usr.id", "return_condition": "conversion_on_or_after", "return_criteria": { "base_query": { "data_source": "product_analytics", "search": { "query": "@type:view" } }, "time_interval": { "type": "calendar", "value": { "alignment": "monday", "quantity": 1, "timezone": "UTC", "type": "week" } } } } }, "to": 1756857600000 }, "type": "retention_grid_request" } } ``` {% /tab %} ### Response {% tab title="200" %} OK {% tab title="Model" %} Response for a retention grid query. | Parent field | Field | Type | Description | | ----------------- | ---------------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- | | | data [*required*] | object | The single JSON:API resource holding a computed retention grid. Its attributes contain the return periods forming the columns and the cohorts forming the rows. | | data | attributes [*required*] | object | Attributes of a retention grid response, containing the cohort rows and the period columns. | | attributes | cohorts | [object] | The cohorts forming the rows of the grid. | | cohorts | cells | [object] | The cells of the row, one per return period. | | cells | cell_count | int64 | Number of entities that returned during the period. | | cells | cell_rate | double | Fraction of the cohort that returned, between `0` and `1`. | | cells | cell_relative_value_change | double | Change in the metric relative to the cohort baseline. | | cells | cell_value | double | Value of the computed metric, when a metric other than the retention rate is requested. | | cells | is_partial_data | boolean | Whether the return period is still open, so the numbers are not yet final. | | cells | return_period_end_time | int64 | End of the return period, in epoch milliseconds. | | cells | return_period_index | int64 | Zero-based index of the return period this cell belongs to. | | cells | return_period_start_time | int64 | Start of the return period, in epoch milliseconds. | | cells | type | enum | Whether the row holds one cohort's own numbers, or the weighted roll-up across every cohort. Allowed enum values: `raw,aggregated` | | cohorts | cohort_end_time | int64 | End of the cohort window, in epoch milliseconds. | | cohorts | cohort_index | int64 | Zero-based index of the cohort in the grid. | | cohorts | cohort_size | int64 | Number of entities in the cohort. | | cohorts | cohort_start_time | int64 | Start of the cohort window, in epoch milliseconds. | | cohorts | group_tags | [string] | The group-by facet values that identify this row. | | cohorts | name | string | Label identifying the cohort, such as the week it started. | | cohorts | type | enum | Whether the row holds one cohort's own numbers, or the weighted roll-up across every cohort. Allowed enum values: `raw,aggregated` | | cohorts | unit | [object] | Unit definitions for the cell values. | | unit | family | string | The unit family (e.g., time, bytes). | | unit | id | int64 | Numeric identifier for the unit. | | unit | name | string | The full name of the unit (e.g., nanosecond). | | unit | plural | string | Plural form of the unit name (e.g., nanoseconds). | | unit | scale_factor | double | Conversion factor relative to the base unit of the family. | | unit | short_name | string | Abbreviated unit name (e.g., ns). | | attributes | retention_entity | string | The entity whose retention was measured. | | attributes | retention_periods | [object] | The return periods forming the columns of the grid. | | retention_periods | unit | string | Time unit of the period, such as `day`, `week`, `month`, or `year`. | | retention_periods | value | int64 | Length of the period, expressed in `unit`. | | attributes | unit | [object] | Unit definitions for the grid values. | | unit | family | string | The unit family (e.g., time, bytes). | | unit | id | int64 | Numeric identifier for the unit. | | unit | name | string | The full name of the unit (e.g., nanosecond). | | unit | plural | string | Plural form of the unit name (e.g., nanoseconds). | | unit | scale_factor | double | Conversion factor relative to the base unit of the family. | | unit | short_name | string | Abbreviated unit name (e.g., ns). | | data | id [*required*] | string | Unique identifier for this response data object. | | data | type [*required*] | enum | The resource type identifier for a retention grid response. Allowed enum values: `retention_grid_response` | {% /tab %} {% tab title="Example" %} ```json { "data": { "attributes": { "cohorts": [ { "cells": [ { "cell_count": "integer", "cell_rate": "number", "cell_relative_value_change": "number", "cell_value": "number", "is_partial_data": false, "return_period_end_time": "integer", "return_period_index": "integer", "return_period_start_time": "integer", "type": "raw" } ], "cohort_end_time": "integer", "cohort_index": "integer", "cohort_size": "integer", "cohort_start_time": "integer", "group_tags": [], "name": "string", "type": "raw", "unit": [ { "family": "time", "id": "integer", "name": "nanosecond", "plural": "string", "scale_factor": "number", "short_name": "string" } ] } ], "retention_entity": "string", "retention_periods": [ { "unit": "week", "value": 1 } ], "unit": [ { "family": "time", "id": "integer", "name": "nanosecond", "plural": "string", "scale_factor": "number", "short_name": "string" } ] }, "id": "00000000-0000-0000-0000-000000000000", "type": "retention_grid_response" } } ``` {% /tab %} {% /tab %} {% tab title="400" %} Bad Request {% tab title="Model" %} API error response. | Field | Type | Description | | ------------------------ | -------- | ----------------- | | errors [*required*] | [string] | A list of errors. | {% /tab %} {% tab title="Example" %} ```json { "errors": [ "Bad Request" ] } ``` {% /tab %} {% /tab %} {% tab title="403" %} Not Authorized {% tab title="Model" %} API error response. | Field | Type | Description | | ------------------------ | -------- | ----------------- | | errors [*required*] | [string] | A list of errors. | {% /tab %} {% tab title="Example" %} ```json { "errors": [ "Bad Request" ] } ``` {% /tab %} {% /tab %} {% tab title="429" %} Too many requests {% tab title="Model" %} API error response. | Field | Type | Description | | ------------------------ | -------- | ----------------- | | errors [*required*] | [string] | A list of errors. | {% /tab %} {% tab title="Example" %} ```json { "errors": [ "Bad Request" ] } ``` {% /tab %} {% /tab %} ### Code Example ##### \## default # \# Curl command curl -X POST "https://api.datadoghq.com/api/v2/product-analytics/retention/grid" \ -H "Accept: application/json" \ -H "Content-Type: application/json" \ -H "DD-API-KEY: ${DD_API_KEY}" \ -H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \ -d @- << EOF { "data": { "attributes": { "from": 1756425600000, "query": { "compute": { "aggregation": "count", "metric": "__dd.retention_rate" }, "search": { "cohort_criteria": { "base_query": { "data_source": "product_analytics", "search": { "query": "@type:view @view.name:Signup" } }, "time_interval": { "type": "calendar", "value": { "alignment": "monday", "quantity": 1, "timezone": "UTC", "type": "week" } } }, "retention_entity": "@usr.id", "return_condition": "conversion_on_or_after", "return_criteria": { "base_query": { "data_source": "product_analytics", "search": { "query": "@type:view" } } } } }, "to": 1756857600000 }, "type": "retention_grid_request" } } EOF ##### ```python """ Compute a retention grid returns "OK" response """ from datadog_api_client import ApiClient, Configuration from datadog_api_client.v2.api.product_analytics_api import ProductAnalyticsApi from datadog_api_client.v2.model.product_analytics_audience_account_subquery import ( ProductAnalyticsAudienceAccountSubquery, ) from datadog_api_client.v2.model.product_analytics_audience_filters import ProductAnalyticsAudienceFilters from datadog_api_client.v2.model.product_analytics_audience_segment_subquery import ( ProductAnalyticsAudienceSegmentSubquery, ) from datadog_api_client.v2.model.product_analytics_audience_user_subquery import ProductAnalyticsAudienceUserSubquery from datadog_api_client.v2.model.product_analytics_calendar_interval import ProductAnalyticsCalendarInterval from datadog_api_client.v2.model.product_analytics_calendar_interval_type import ProductAnalyticsCalendarIntervalType from datadog_api_client.v2.model.product_analytics_event_query import ProductAnalyticsEventQuery from datadog_api_client.v2.model.product_analytics_event_query_data_source import ProductAnalyticsEventQueryDataSource from datadog_api_client.v2.model.product_analytics_event_search import ProductAnalyticsEventSearch from datadog_api_client.v2.model.product_analytics_group_by_sort import ProductAnalyticsGroupBySort from datadog_api_client.v2.model.product_analytics_retention_calendar_time_interval import ( ProductAnalyticsRetentionCalendarTimeInterval, ) from datadog_api_client.v2.model.product_analytics_retention_calendar_time_interval_type import ( ProductAnalyticsRetentionCalendarTimeIntervalType, ) from datadog_api_client.v2.model.product_analytics_retention_cohort_criteria import ( ProductAnalyticsRetentionCohortCriteria, ) from datadog_api_client.v2.model.product_analytics_retention_cohort_scope import ProductAnalyticsRetentionCohortScope from datadog_api_client.v2.model.product_analytics_retention_cohort_scope_type import ( ProductAnalyticsRetentionCohortScopeType, ) from datadog_api_client.v2.model.product_analytics_retention_compute import ProductAnalyticsRetentionCompute from datadog_api_client.v2.model.product_analytics_retention_compute_metric import ( ProductAnalyticsRetentionComputeMetric, ) from datadog_api_client.v2.model.product_analytics_retention_entity import ProductAnalyticsRetentionEntity from datadog_api_client.v2.model.product_analytics_retention_filters import ProductAnalyticsRetentionFilters from datadog_api_client.v2.model.product_analytics_retention_grid_query import ProductAnalyticsRetentionGridQuery from datadog_api_client.v2.model.product_analytics_retention_grid_request import ProductAnalyticsRetentionGridRequest from datadog_api_client.v2.model.product_analytics_retention_grid_request_attributes import ( ProductAnalyticsRetentionGridRequestAttributes, ) from datadog_api_client.v2.model.product_analytics_retention_grid_request_data import ( ProductAnalyticsRetentionGridRequestData, ) from datadog_api_client.v2.model.product_analytics_retention_grid_request_type import ( ProductAnalyticsRetentionGridRequestType, ) from datadog_api_client.v2.model.product_analytics_retention_group_by import ProductAnalyticsRetentionGroupBy from datadog_api_client.v2.model.product_analytics_retention_group_by_target import ( ProductAnalyticsRetentionGroupByTarget, ) from datadog_api_client.v2.model.product_analytics_retention_index_target import ProductAnalyticsRetentionIndexTarget from datadog_api_client.v2.model.product_analytics_retention_index_target_type import ( ProductAnalyticsRetentionIndexTargetType, ) from datadog_api_client.v2.model.product_analytics_retention_return_condition import ( ProductAnalyticsRetentionReturnCondition, ) from datadog_api_client.v2.model.product_analytics_retention_return_criteria import ( ProductAnalyticsRetentionReturnCriteria, ) from datadog_api_client.v2.model.product_analytics_retention_search import ProductAnalyticsRetentionSearch from datadog_api_client.v2.model.query_sort_order import QuerySortOrder from uuid import UUID body = ProductAnalyticsRetentionGridRequest( data=ProductAnalyticsRetentionGridRequestData( attributes=ProductAnalyticsRetentionGridRequestAttributes( exclude_anonymous_traffic=False, _from=1756425600000, query=ProductAnalyticsRetentionGridQuery( computation_scope=ProductAnalyticsRetentionCohortScope( target=ProductAnalyticsRetentionIndexTarget( type=ProductAnalyticsRetentionIndexTargetType.INDEX, value=0, ), type=ProductAnalyticsRetentionCohortScopeType.COHORT, ), compute=ProductAnalyticsRetentionCompute( aggregation="count", metric=ProductAnalyticsRetentionComputeMetric.RETENTION_RATE, ), group_by=[ ProductAnalyticsRetentionGroupBy( facet="@geo.country", limit=10, should_exclude_missing=False, sort=ProductAnalyticsGroupBySort( aggregation="count", order=QuerySortOrder.DESC, ), target=ProductAnalyticsRetentionGroupByTarget.COHORT, ), ], search=ProductAnalyticsRetentionSearch( cohort_criteria=ProductAnalyticsRetentionCohortCriteria( base_query=ProductAnalyticsEventQuery( data_source=ProductAnalyticsEventQueryDataSource.PRODUCT_ANALYTICS, search=ProductAnalyticsEventSearch( query="@type:view", ), ), time_interval=ProductAnalyticsRetentionCalendarTimeInterval( type=ProductAnalyticsRetentionCalendarTimeIntervalType.CALENDAR, value=ProductAnalyticsCalendarInterval( alignment="monday", quantity=1, timezone="UTC", type=ProductAnalyticsCalendarIntervalType.WEEK, ), ), ), filters=ProductAnalyticsRetentionFilters( audience_filters=ProductAnalyticsAudienceFilters( accounts=[ ProductAnalyticsAudienceAccountSubquery( name="", ), ], formula="u", segments=[ ProductAnalyticsAudienceSegmentSubquery( name="", segment_id=UUID("00000000-0000-0000-0000-000000000000"), ), ], users=[ ProductAnalyticsAudienceUserSubquery( name="u", query="*", ), ], ), ), retention_entity=ProductAnalyticsRetentionEntity.USER_ID, return_condition=ProductAnalyticsRetentionReturnCondition.CONVERSION_ON_OR_AFTER, return_criteria=ProductAnalyticsRetentionReturnCriteria( base_query=ProductAnalyticsEventQuery( data_source=ProductAnalyticsEventQueryDataSource.PRODUCT_ANALYTICS, search=ProductAnalyticsEventSearch( query="@type:view", ), ), time_interval=ProductAnalyticsRetentionCalendarTimeInterval( type=ProductAnalyticsRetentionCalendarTimeIntervalType.CALENDAR, value=ProductAnalyticsCalendarInterval( alignment="monday", quantity=1, timezone="UTC", type=ProductAnalyticsCalendarIntervalType.WEEK, ), ), ), ), ), to=1756857600000, ), type=ProductAnalyticsRetentionGridRequestType.RETENTION_GRID_REQUEST, ), ) configuration = Configuration() configuration.unstable_operations["query_product_analytics_retention_grid"] = True with ApiClient(configuration) as api_client: api_instance = ProductAnalyticsApi(api_client) response = api_instance.query_product_analytics_retention_grid(body=body) print(response) ``` #### Instructions First [install the library and its dependencies](https://docs.datadoghq.com/api/latest.md?code-lang=python) and then save the example to `example.py` and run following commands: DD_SITE="datadoghq.com" DD_API_KEY="" DD_APP_KEY="" python3 "example.py" ##### ```ruby # Compute a retention grid returns "OK" response require "datadog_api_client" DatadogAPIClient.configure do |config| config.unstable_operations["v2.query_product_analytics_retention_grid".to_sym] = true end api_instance = DatadogAPIClient::V2::ProductAnalyticsAPI.new body = DatadogAPIClient::V2::ProductAnalyticsRetentionGridRequest.new({ data: DatadogAPIClient::V2::ProductAnalyticsRetentionGridRequestData.new({ attributes: DatadogAPIClient::V2::ProductAnalyticsRetentionGridRequestAttributes.new({ exclude_anonymous_traffic: false, from: 1756425600000, query: DatadogAPIClient::V2::ProductAnalyticsRetentionGridQuery.new({ computation_scope: DatadogAPIClient::V2::ProductAnalyticsRetentionCohortScope.new({ target: DatadogAPIClient::V2::ProductAnalyticsRetentionIndexTarget.new({ type: DatadogAPIClient::V2::ProductAnalyticsRetentionIndexTargetType::INDEX, value: 0, }), type: DatadogAPIClient::V2::ProductAnalyticsRetentionCohortScopeType::COHORT, }), compute: DatadogAPIClient::V2::ProductAnalyticsRetentionCompute.new({ aggregation: "count", metric: DatadogAPIClient::V2::ProductAnalyticsRetentionComputeMetric::RETENTION_RATE, }), group_by: [ DatadogAPIClient::V2::ProductAnalyticsRetentionGroupBy.new({ facet: "@geo.country", limit: 10, should_exclude_missing: false, sort: DatadogAPIClient::V2::ProductAnalyticsGroupBySort.new({ aggregation: "count", order: DatadogAPIClient::V2::QuerySortOrder::DESC, }), target: DatadogAPIClient::V2::ProductAnalyticsRetentionGroupByTarget::COHORT, }), ], search: DatadogAPIClient::V2::ProductAnalyticsRetentionSearch.new({ cohort_criteria: DatadogAPIClient::V2::ProductAnalyticsRetentionCohortCriteria.new({ base_query: DatadogAPIClient::V2::ProductAnalyticsEventQuery.new({ data_source: DatadogAPIClient::V2::ProductAnalyticsEventQueryDataSource::PRODUCT_ANALYTICS, search: DatadogAPIClient::V2::ProductAnalyticsEventSearch.new({ query: "@type:view", }), }), time_interval: DatadogAPIClient::V2::ProductAnalyticsRetentionCalendarTimeInterval.new({ type: DatadogAPIClient::V2::ProductAnalyticsRetentionCalendarTimeIntervalType::CALENDAR, value: DatadogAPIClient::V2::ProductAnalyticsCalendarInterval.new({ alignment: "monday", quantity: 1, timezone: "UTC", type: DatadogAPIClient::V2::ProductAnalyticsCalendarIntervalType::WEEK, }), }), }), filters: DatadogAPIClient::V2::ProductAnalyticsRetentionFilters.new({ audience_filters: DatadogAPIClient::V2::ProductAnalyticsAudienceFilters.new({ accounts: [ DatadogAPIClient::V2::ProductAnalyticsAudienceAccountSubquery.new({ name: "", }), ], formula: "u", segments: [ DatadogAPIClient::V2::ProductAnalyticsAudienceSegmentSubquery.new({ name: "", segment_id: "00000000-0000-0000-0000-000000000000", }), ], users: [ DatadogAPIClient::V2::ProductAnalyticsAudienceUserSubquery.new({ name: "u", query: "*", }), ], }), }), retention_entity: DatadogAPIClient::V2::ProductAnalyticsRetentionEntity::USER_ID, return_condition: DatadogAPIClient::V2::ProductAnalyticsRetentionReturnCondition::CONVERSION_ON_OR_AFTER, return_criteria: DatadogAPIClient::V2::ProductAnalyticsRetentionReturnCriteria.new({ base_query: DatadogAPIClient::V2::ProductAnalyticsEventQuery.new({ data_source: DatadogAPIClient::V2::ProductAnalyticsEventQueryDataSource::PRODUCT_ANALYTICS, search: DatadogAPIClient::V2::ProductAnalyticsEventSearch.new({ query: "@type:view", }), }), time_interval: DatadogAPIClient::V2::ProductAnalyticsRetentionCalendarTimeInterval.new({ type: DatadogAPIClient::V2::ProductAnalyticsRetentionCalendarTimeIntervalType::CALENDAR, value: DatadogAPIClient::V2::ProductAnalyticsCalendarInterval.new({ alignment: "monday", quantity: 1, timezone: "UTC", type: DatadogAPIClient::V2::ProductAnalyticsCalendarIntervalType::WEEK, }), }), }), }), }), to: 1756857600000, }), type: DatadogAPIClient::V2::ProductAnalyticsRetentionGridRequestType::RETENTION_GRID_REQUEST, }), }) p api_instance.query_product_analytics_retention_grid(body) ``` #### Instructions First [install the library and its dependencies](https://docs.datadoghq.com/api/latest.md?code-lang=ruby) and then save the example to `example.rb` and run following commands: DD_SITE="datadoghq.com" DD_API_KEY="" DD_APP_KEY="" rb "example.rb" ##### ```go // Compute a retention grid returns "OK" response package main import ( "context" "encoding/json" "fmt" "os" "github.com/DataDog/datadog-api-client-go/v2/api/datadog" "github.com/DataDog/datadog-api-client-go/v2/api/datadogV2" "github.com/google/uuid" ) func main() { body := datadogV2.ProductAnalyticsRetentionGridRequest{ Data: datadogV2.ProductAnalyticsRetentionGridRequestData{ Attributes: datadogV2.ProductAnalyticsRetentionGridRequestAttributes{ ExcludeAnonymousTraffic: datadog.PtrBool(false), From: 1756425600000, Query: datadogV2.ProductAnalyticsRetentionGridQuery{ ComputationScope: &datadogV2.ProductAnalyticsRetentionScope{ ProductAnalyticsRetentionCohortScope: &datadogV2.ProductAnalyticsRetentionCohortScope{ Target: datadogV2.ProductAnalyticsRetentionCohortTarget{ ProductAnalyticsRetentionIndexTarget: &datadogV2.ProductAnalyticsRetentionIndexTarget{ Type: datadogV2.PRODUCTANALYTICSRETENTIONINDEXTARGETTYPE_INDEX, Value: 0, }}, Type: datadogV2.PRODUCTANALYTICSRETENTIONCOHORTSCOPETYPE_COHORT, }}, Compute: datadogV2.ProductAnalyticsRetentionCompute{ Aggregation: "count", Metric: datadogV2.PRODUCTANALYTICSRETENTIONCOMPUTEMETRIC_RETENTION_RATE, }, GroupBy: []datadogV2.ProductAnalyticsRetentionGroupBy{ { Facet: "@geo.country", Limit: datadog.PtrInt64(10), ShouldExcludeMissing: datadog.PtrBool(false), Sort: &datadogV2.ProductAnalyticsGroupBySort{ Aggregation: datadog.PtrString("count"), Order: datadogV2.QUERYSORTORDER_DESC.Ptr(), }, Target: datadogV2.PRODUCTANALYTICSRETENTIONGROUPBYTARGET_COHORT, }, }, Search: datadogV2.ProductAnalyticsRetentionSearch{ CohortCriteria: datadogV2.ProductAnalyticsRetentionCohortCriteria{ BaseQuery: datadogV2.ProductAnalyticsBaseQuery{ ProductAnalyticsEventQuery: &datadogV2.ProductAnalyticsEventQuery{ DataSource: datadogV2.PRODUCTANALYTICSEVENTQUERYDATASOURCE_PRODUCT_ANALYTICS, Search: datadogV2.ProductAnalyticsEventSearch{ Query: datadog.PtrString("@type:view"), }, }}, TimeInterval: datadogV2.ProductAnalyticsRetentionTimeInterval{ ProductAnalyticsRetentionCalendarTimeInterval: &datadogV2.ProductAnalyticsRetentionCalendarTimeInterval{ Type: datadogV2.PRODUCTANALYTICSRETENTIONCALENDARTIMEINTERVALTYPE_CALENDAR, Value: datadogV2.ProductAnalyticsCalendarInterval{ Alignment: datadog.PtrString("monday"), Quantity: datadog.PtrInt64(1), Timezone: datadog.PtrString("UTC"), Type: datadogV2.PRODUCTANALYTICSCALENDARINTERVALTYPE_WEEK, }, }}, }, Filters: &datadogV2.ProductAnalyticsRetentionFilters{ AudienceFilters: &datadogV2.ProductAnalyticsAudienceFilters{ Accounts: []datadogV2.ProductAnalyticsAudienceAccountSubquery{ { Name: "", }, }, Formula: datadog.PtrString("u"), Segments: []datadogV2.ProductAnalyticsAudienceSegmentSubquery{ { Name: "", SegmentId: uuid.MustParse("00000000-0000-0000-0000-000000000000"), }, }, Users: []datadogV2.ProductAnalyticsAudienceUserSubquery{ { Name: "u", Query: datadog.PtrString("*"), }, }, }, }, RetentionEntity: datadogV2.PRODUCTANALYTICSRETENTIONENTITY_USER_ID, ReturnCondition: datadogV2.PRODUCTANALYTICSRETENTIONRETURNCONDITION_CONVERSION_ON_OR_AFTER, ReturnCriteria: &datadogV2.ProductAnalyticsRetentionReturnCriteria{ BaseQuery: datadogV2.ProductAnalyticsBaseQuery{ ProductAnalyticsEventQuery: &datadogV2.ProductAnalyticsEventQuery{ DataSource: datadogV2.PRODUCTANALYTICSEVENTQUERYDATASOURCE_PRODUCT_ANALYTICS, Search: datadogV2.ProductAnalyticsEventSearch{ Query: datadog.PtrString("@type:view"), }, }}, TimeInterval: &datadogV2.ProductAnalyticsRetentionTimeInterval{ ProductAnalyticsRetentionCalendarTimeInterval: &datadogV2.ProductAnalyticsRetentionCalendarTimeInterval{ Type: datadogV2.PRODUCTANALYTICSRETENTIONCALENDARTIMEINTERVALTYPE_CALENDAR, Value: datadogV2.ProductAnalyticsCalendarInterval{ Alignment: datadog.PtrString("monday"), Quantity: datadog.PtrInt64(1), Timezone: datadog.PtrString("UTC"), Type: datadogV2.PRODUCTANALYTICSCALENDARINTERVALTYPE_WEEK, }, }}, }, }, }, To: 1756857600000, }, Type: datadogV2.PRODUCTANALYTICSRETENTIONGRIDREQUESTTYPE_RETENTION_GRID_REQUEST, }, } ctx := datadog.NewDefaultContext(context.Background()) configuration := datadog.NewConfiguration() configuration.SetUnstableOperationEnabled("v2.QueryProductAnalyticsRetentionGrid", true) apiClient := datadog.NewAPIClient(configuration) api := datadogV2.NewProductAnalyticsApi(apiClient) resp, r, err := api.QueryProductAnalyticsRetentionGrid(ctx, body) if err != nil { fmt.Fprintf(os.Stderr, "Error when calling `ProductAnalyticsApi.QueryProductAnalyticsRetentionGrid`: %v\n", err) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) } responseContent, _ := json.MarshalIndent(resp, "", " ") fmt.Fprintf(os.Stdout, "Response from `ProductAnalyticsApi.QueryProductAnalyticsRetentionGrid`:\n%s\n", responseContent) } ``` #### Instructions First [install the library and its dependencies](https://docs.datadoghq.com/api/latest.md?code-lang=go) and then save the example to `main.go` and run following commands: DD_SITE="datadoghq.com" DD_API_KEY="" DD_APP_KEY="" go run "main.go" ##### ```java // Compute a retention grid returns "OK" response import com.datadog.api.client.ApiClient; import com.datadog.api.client.ApiException; import com.datadog.api.client.v2.api.ProductAnalyticsApi; import com.datadog.api.client.v2.model.ProductAnalyticsAudienceAccountSubquery; import com.datadog.api.client.v2.model.ProductAnalyticsAudienceFilters; import com.datadog.api.client.v2.model.ProductAnalyticsAudienceSegmentSubquery; import com.datadog.api.client.v2.model.ProductAnalyticsAudienceUserSubquery; import com.datadog.api.client.v2.model.ProductAnalyticsBaseQuery; import com.datadog.api.client.v2.model.ProductAnalyticsCalendarInterval; import com.datadog.api.client.v2.model.ProductAnalyticsCalendarIntervalType; import com.datadog.api.client.v2.model.ProductAnalyticsEventQuery; import com.datadog.api.client.v2.model.ProductAnalyticsEventQueryDataSource; import com.datadog.api.client.v2.model.ProductAnalyticsEventSearch; import com.datadog.api.client.v2.model.ProductAnalyticsGroupBySort; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionCalendarTimeInterval; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionCalendarTimeIntervalType; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionCohortCriteria; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionCohortScope; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionCohortScopeType; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionCohortTarget; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionCompute; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionComputeMetric; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionEntity; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionFilters; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionGridQuery; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionGridRequest; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionGridRequestAttributes; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionGridRequestData; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionGridRequestType; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionGridResponse; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionGroupBy; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionGroupByTarget; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionIndexTarget; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionIndexTargetType; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionReturnCondition; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionReturnCriteria; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionScope; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionSearch; import com.datadog.api.client.v2.model.ProductAnalyticsRetentionTimeInterval; import com.datadog.api.client.v2.model.QuerySortOrder; import java.util.Collections; import java.util.UUID; public class Example { public static void main(String[] args) { ApiClient defaultClient = ApiClient.getDefaultApiClient(); defaultClient.setUnstableOperationEnabled("v2.queryProductAnalyticsRetentionGrid", true); ProductAnalyticsApi apiInstance = new ProductAnalyticsApi(defaultClient); ProductAnalyticsRetentionGridRequest body = new ProductAnalyticsRetentionGridRequest() .data( new ProductAnalyticsRetentionGridRequestData() .attributes( new ProductAnalyticsRetentionGridRequestAttributes() .excludeAnonymousTraffic(false) .from(1756425600000L) .query( new ProductAnalyticsRetentionGridQuery() .computationScope( new ProductAnalyticsRetentionScope( new ProductAnalyticsRetentionCohortScope() .target( new ProductAnalyticsRetentionCohortTarget( new ProductAnalyticsRetentionIndexTarget() .type( ProductAnalyticsRetentionIndexTargetType .INDEX) .value(0L))) .type( ProductAnalyticsRetentionCohortScopeType .COHORT))) .compute( new ProductAnalyticsRetentionCompute() .aggregation("count") .metric( ProductAnalyticsRetentionComputeMetric .RETENTION_RATE)) .groupBy( Collections.singletonList( new ProductAnalyticsRetentionGroupBy() .facet("@geo.country") .limit(10L) .shouldExcludeMissing(false) .sort( new ProductAnalyticsGroupBySort() .aggregation("count") .order(QuerySortOrder.DESC)) .target( ProductAnalyticsRetentionGroupByTarget.COHORT))) .search( new ProductAnalyticsRetentionSearch() .cohortCriteria( new ProductAnalyticsRetentionCohortCriteria() .baseQuery( new ProductAnalyticsBaseQuery( new ProductAnalyticsEventQuery() .dataSource( ProductAnalyticsEventQueryDataSource .PRODUCT_ANALYTICS) .search( new ProductAnalyticsEventSearch() .query("@type:view")))) .timeInterval( new ProductAnalyticsRetentionTimeInterval( new ProductAnalyticsRetentionCalendarTimeInterval() .type( ProductAnalyticsRetentionCalendarTimeIntervalType .CALENDAR) .value( new ProductAnalyticsCalendarInterval() .alignment("monday") .quantity(1L) .timezone("UTC") .type( ProductAnalyticsCalendarIntervalType .WEEK))))) .filters( new ProductAnalyticsRetentionFilters() .audienceFilters( new ProductAnalyticsAudienceFilters() .accounts( Collections.singletonList( new ProductAnalyticsAudienceAccountSubquery() .name(""))) .formula("u") .segments( Collections.singletonList( new ProductAnalyticsAudienceSegmentSubquery() .name("") .segmentId( UUID.fromString( "00000000-0000-0000-0000-000000000000")))) .users( Collections.singletonList( new ProductAnalyticsAudienceUserSubquery() .name("u") .query("*"))))) .retentionEntity( ProductAnalyticsRetentionEntity.USER_ID) .returnCondition( ProductAnalyticsRetentionReturnCondition .CONVERSION_ON_OR_AFTER) .returnCriteria( new ProductAnalyticsRetentionReturnCriteria() .baseQuery( new ProductAnalyticsBaseQuery( new ProductAnalyticsEventQuery() .dataSource( ProductAnalyticsEventQueryDataSource .PRODUCT_ANALYTICS) .search( new ProductAnalyticsEventSearch() .query("@type:view")))) .timeInterval( new ProductAnalyticsRetentionTimeInterval( new ProductAnalyticsRetentionCalendarTimeInterval() .type( ProductAnalyticsRetentionCalendarTimeIntervalType .CALENDAR) .value( new ProductAnalyticsCalendarInterval() .alignment("monday") .quantity(1L) .timezone("UTC") .type( ProductAnalyticsCalendarIntervalType .WEEK))))))) .to(1756857600000L)) .type(ProductAnalyticsRetentionGridRequestType.RETENTION_GRID_REQUEST)); try { ProductAnalyticsRetentionGridResponse result = apiInstance.queryProductAnalyticsRetentionGrid(body); System.out.println(result); } catch (ApiException e) { System.err.println( "Exception when calling ProductAnalyticsApi#queryProductAnalyticsRetentionGrid"); System.err.println("Status code: " + e.getCode()); System.err.println("Reason: " + e.getResponseBody()); System.err.println("Response headers: " + e.getResponseHeaders()); e.printStackTrace(); } } } ``` #### Instructions First [install the library and its dependencies](https://docs.datadoghq.com/api/latest.md?code-lang=java) and then save the example to `Example.java` and run following commands: DD_SITE="datadoghq.com" DD_API_KEY="" DD_APP_KEY="" java "Example.java" ##### ```rust // Compute a retention grid returns "OK" response use datadog_api_client::datadog; use datadog_api_client::datadogV2::api_product_analytics::ProductAnalyticsAPI; use datadog_api_client::datadogV2::model::ProductAnalyticsAudienceAccountSubquery; use datadog_api_client::datadogV2::model::ProductAnalyticsAudienceFilters; use datadog_api_client::datadogV2::model::ProductAnalyticsAudienceSegmentSubquery; use datadog_api_client::datadogV2::model::ProductAnalyticsAudienceUserSubquery; use datadog_api_client::datadogV2::model::ProductAnalyticsBaseQuery; use datadog_api_client::datadogV2::model::ProductAnalyticsCalendarInterval; use datadog_api_client::datadogV2::model::ProductAnalyticsCalendarIntervalType; use datadog_api_client::datadogV2::model::ProductAnalyticsEventQuery; use datadog_api_client::datadogV2::model::ProductAnalyticsEventQueryDataSource; use datadog_api_client::datadogV2::model::ProductAnalyticsEventSearch; use datadog_api_client::datadogV2::model::ProductAnalyticsGroupBySort; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionCalendarTimeInterval; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionCalendarTimeIntervalType; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionCohortCriteria; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionCohortScope; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionCohortScopeType; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionCohortTarget; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionCompute; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionComputeMetric; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionEntity; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionFilters; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionGridQuery; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionGridRequest; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionGridRequestAttributes; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionGridRequestData; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionGridRequestType; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionGroupBy; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionGroupByTarget; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionIndexTarget; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionIndexTargetType; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionReturnCondition; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionReturnCriteria; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionScope; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionSearch; use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionTimeInterval; use datadog_api_client::datadogV2::model::QuerySortOrder; use uuid::Uuid; #[tokio::main] async fn main() { let body = ProductAnalyticsRetentionGridRequest::new( ProductAnalyticsRetentionGridRequestData::new( ProductAnalyticsRetentionGridRequestAttributes::new( 1756425600000, ProductAnalyticsRetentionGridQuery::new( ProductAnalyticsRetentionCompute::new( "count".to_string(), ProductAnalyticsRetentionComputeMetric::RETENTION_RATE, ), ProductAnalyticsRetentionSearch::new( ProductAnalyticsRetentionCohortCriteria::new( ProductAnalyticsBaseQuery::ProductAnalyticsEventQuery( Box::new( ProductAnalyticsEventQuery::new( ProductAnalyticsEventQueryDataSource::PRODUCT_ANALYTICS, ProductAnalyticsEventSearch::new().query("@type:view".to_string()), ), ), ), ProductAnalyticsRetentionTimeInterval::ProductAnalyticsRetentionCalendarTimeInterval( Box::new( ProductAnalyticsRetentionCalendarTimeInterval::new( ProductAnalyticsRetentionCalendarTimeIntervalType::CALENDAR, ProductAnalyticsCalendarInterval::new( ProductAnalyticsCalendarIntervalType::WEEK, ) .alignment("monday".to_string()) .quantity(1) .timezone("UTC".to_string()), ), ), ), ), ProductAnalyticsRetentionEntity::USER_ID, ProductAnalyticsRetentionReturnCondition::CONVERSION_ON_OR_AFTER, ) .filters( ProductAnalyticsRetentionFilters ::new().audience_filters( ProductAnalyticsAudienceFilters::new() .accounts(vec![ProductAnalyticsAudienceAccountSubquery::new("".to_string())]) .formula("u".to_string()) .segments( vec![ ProductAnalyticsAudienceSegmentSubquery::new( "".to_string(), Uuid::parse_str( "00000000-0000-0000-0000-000000000000", ).expect("invalid UUID"), ) ], ) .users( vec![ ProductAnalyticsAudienceUserSubquery::new( "u".to_string(), ).query("*".to_string()) ], ), ), ) .return_criteria( ProductAnalyticsRetentionReturnCriteria::new( ProductAnalyticsBaseQuery::ProductAnalyticsEventQuery( Box::new( ProductAnalyticsEventQuery::new( ProductAnalyticsEventQueryDataSource::PRODUCT_ANALYTICS, ProductAnalyticsEventSearch::new().query("@type:view".to_string()), ), ), ), ).time_interval( ProductAnalyticsRetentionTimeInterval ::ProductAnalyticsRetentionCalendarTimeInterval( Box::new( ProductAnalyticsRetentionCalendarTimeInterval::new( ProductAnalyticsRetentionCalendarTimeIntervalType::CALENDAR, ProductAnalyticsCalendarInterval::new( ProductAnalyticsCalendarIntervalType::WEEK, ) .alignment("monday".to_string()) .quantity(1) .timezone("UTC".to_string()), ), ), ), ), ), ) .computation_scope( ProductAnalyticsRetentionScope::ProductAnalyticsRetentionCohortScope( Box::new( ProductAnalyticsRetentionCohortScope::new( ProductAnalyticsRetentionCohortTarget::ProductAnalyticsRetentionIndexTarget( Box::new( ProductAnalyticsRetentionIndexTarget::new( ProductAnalyticsRetentionIndexTargetType::INDEX, 0, ), ), ), ProductAnalyticsRetentionCohortScopeType::COHORT, ), ), ), ) .group_by( vec![ ProductAnalyticsRetentionGroupBy::new( "@geo.country".to_string(), ProductAnalyticsRetentionGroupByTarget::COHORT, ) .limit(10) .should_exclude_missing(false) .sort( ProductAnalyticsGroupBySort::new() .aggregation("count".to_string()) .order(QuerySortOrder::DESC), ) ], ), 1756857600000, ).exclude_anonymous_traffic(false), ProductAnalyticsRetentionGridRequestType::RETENTION_GRID_REQUEST, ), ); let mut configuration = datadog::Configuration::new(); configuration.set_unstable_operation_enabled("v2.QueryProductAnalyticsRetentionGrid", true); let api = ProductAnalyticsAPI::with_config(configuration); let resp = api.query_product_analytics_retention_grid(body).await; if let Ok(value) = resp { println!("{:#?}", value); } else { println!("{:#?}", resp.unwrap_err()); } } ``` #### Instructions First [install the library and its dependencies](https://docs.datadoghq.com/api/latest.md?code-lang=rust) and then save the example to `src/main.rs` and run following commands: DD_SITE="datadoghq.com" DD_API_KEY="" DD_APP_KEY="" cargo run ##### ```typescript /** * Compute a retention grid returns "OK" response */ import { client, v2 } from "@datadog/datadog-api-client"; const configuration = client.createConfiguration(); configuration.unstableOperations["v2.queryProductAnalyticsRetentionGrid"] = true; const apiInstance = new v2.ProductAnalyticsApi(configuration); const params: v2.ProductAnalyticsApiQueryProductAnalyticsRetentionGridRequest = { body: { data: { attributes: { excludeAnonymousTraffic: false, from: 1756425600000, query: { computationScope: { target: { type: "index", value: 0, }, type: "cohort", }, compute: { aggregation: "count", metric: "__dd.retention_rate", }, groupBy: [ { facet: "@geo.country", limit: 10, shouldExcludeMissing: false, sort: { aggregation: "count", order: "desc", }, target: "cohort", }, ], search: { cohortCriteria: { baseQuery: { dataSource: "product_analytics", search: { query: "@type:view", }, }, timeInterval: { type: "calendar", value: { alignment: "monday", quantity: 1, timezone: "UTC", type: "week", }, }, }, filters: { audienceFilters: { accounts: [ { name: "", }, ], formula: "u", segments: [ { name: "", segmentId: "00000000-0000-0000-0000-000000000000", }, ], users: [ { name: "u", query: "*", }, ], }, }, retentionEntity: "@usr.id", returnCondition: "conversion_on_or_after", returnCriteria: { baseQuery: { dataSource: "product_analytics", search: { query: "@type:view", }, }, timeInterval: { type: "calendar", value: { alignment: "monday", quantity: 1, timezone: "UTC", type: "week", }, }, }, }, }, to: 1756857600000, }, type: "retention_grid_request", }, }, }; apiInstance .queryProductAnalyticsRetentionGrid(params) .then((data: v2.ProductAnalyticsRetentionGridResponse) => { console.log( "API called successfully. Returned data: " + JSON.stringify(data) ); }) .catch((error: any) => console.error(error)); ``` #### Instructions First [install the library and its dependencies](https://docs.datadoghq.com/api/latest.md?code-lang=typescript) and then save the example to `example.ts` and run following commands: DD_SITE="datadoghq.com" DD_API_KEY="" DD_APP_KEY="" tsc "example.ts" {% /tab %}