List the entities behind a retention cell

v2 (latest)

Note: This endpoint is in preview and is subject to change. If you have any feedback, contact Datadog support.

POST https://api.ap1.datadoghq.com/api/v2/product-analytics/retention/listhttps://api.ap2.datadoghq.com/api/v2/product-analytics/retention/listhttps://api.datadoghq.eu/api/v2/product-analytics/retention/listhttps://api.ddog-gov.com/api/v2/product-analytics/retention/listhttps://api.us2.ddog-gov.com/api/v2/product-analytics/retention/listhttps://api.uk1.datadoghq.com/api/v2/product-analytics/retention/listhttps://api.datadoghq.com/api/v2/product-analytics/retention/listhttps://api.us3.datadoghq.com/api/v2/product-analytics/retention/listhttps://api.us5.datadoghq.com/api/v2/product-analytics/retention/list

Overview

List the individual users or accounts counted in one cell of the retention grid. Set computation_scope to the cohort and return period you want to examine. This endpoint requires the rum_apps_read permission.

Request

Body Data (required)

The retention list query.

Expand All

Field

Type

Description

data [required]

object

The single JSON:API resource carrying a retention list query. Its attributes hold the time window, the cell to list, and the columns to return for each entity.

attributes [required]

object

Attributes of a retention list request.

query [required]

object

Query definition for a retention list request.

search [required]

object

Defines the cohort and return criteria that make up a retention query.

cohort_criteria [required]

object

Defines the event that places an entity into a cohort, and how cohorts are bucketed over time.

return_criteria

object

Defines the event that counts as a return, and the window in which it must occur.

{
  "data": {
    "attributes": {
      "from": 1756425600000,
      "query": {
        "columns": [
          {
            "field": {
              "path": "@usr.email"
            }
          }
        ],
        "computation_scope": {
          "cohort_target": {
            "type": "index",
            "value": 0
          },
          "return_period_target": {
            "type": "index",
            "value": 0
          },
          "type": "cell"
        },
        "limit": 100,
        "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_list_request"
  }
}

Response

Response for a retention list query.

Expand All

Field

Type

Description

data [required]

object

The single JSON:API resource holding the entities behind one retention cell. Its attributes contain the entity whose retention was measured and one row per matching entity.

{
  "data": {
    "attributes": {
      "records": [],
      "retention_entity": "string"
    },
    "id": "00000000-0000-0000-0000-000000000000",
    "type": "retention_list_response"
  }
}

Bad Request

API error response.

Expand All

Field

Type

Description

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Not Authorized

API error response.

Expand All

Field

Type

Description

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Too many requests

API error response.

Expand All

Field

Type

Description

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Code Example

                  ## default
# 

# Curl command
curl -X POST "https://api.ap1.datadoghq.com"https://api.ap2.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.us2.ddog-gov.com"https://api.uk1.datadoghq.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/product-analytics/retention/list" \
-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": {
        "columns": [
          {
            "field": {
              "path": "@usr.email"
            }
          }
        ],
        "computation_scope": {
          "cohort_target": {
            "type": "index",
            "value": 0
          },
          "return_period_target": {
            "type": "index",
            "value": 1
          },
          "type": "cell"
        },
        "limit": 100,
        "search": {
          "cohort_criteria": {
            "base_query": {
              "data_source": "product_analytics",
              "search": {
                "query": "@type:view @view.name:Signup"
              }
            },
            "time_interval": {
              "type": "calendar",
              "value": {
                "quantity": 1,
                "type": "week"
              }
            }
          },
          "retention_entity": "@usr.id",
          "return_condition": "conversion_on_or_after"
        }
      },
      "to": 1756857600000
    },
    "type": "retention_list_request"
  }
}
EOF

                

"""
List the entities behind a retention cell 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_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_cell_scope import ProductAnalyticsRetentionCellScope
from datadog_api_client.v2.model.product_analytics_retention_cell_scope_type import (
    ProductAnalyticsRetentionCellScopeType,
)
from datadog_api_client.v2.model.product_analytics_retention_cohort_criteria import (
    ProductAnalyticsRetentionCohortCriteria,
)
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_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_list_column import ProductAnalyticsRetentionListColumn
from datadog_api_client.v2.model.product_analytics_retention_list_column_field import (
    ProductAnalyticsRetentionListColumnField,
)
from datadog_api_client.v2.model.product_analytics_retention_list_query import ProductAnalyticsRetentionListQuery
from datadog_api_client.v2.model.product_analytics_retention_list_request import ProductAnalyticsRetentionListRequest
from datadog_api_client.v2.model.product_analytics_retention_list_request_attributes import (
    ProductAnalyticsRetentionListRequestAttributes,
)
from datadog_api_client.v2.model.product_analytics_retention_list_request_data import (
    ProductAnalyticsRetentionListRequestData,
)
from datadog_api_client.v2.model.product_analytics_retention_list_request_type import (
    ProductAnalyticsRetentionListRequestType,
)
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 uuid import UUID

body = ProductAnalyticsRetentionListRequest(
    data=ProductAnalyticsRetentionListRequestData(
        attributes=ProductAnalyticsRetentionListRequestAttributes(
            _from=1756425600000,
            query=ProductAnalyticsRetentionListQuery(
                columns=[
                    ProductAnalyticsRetentionListColumn(
                        field=ProductAnalyticsRetentionListColumnField(
                            path="@usr.email",
                        ),
                    ),
                ],
                computation_scope=ProductAnalyticsRetentionCellScope(
                    cohort_target=ProductAnalyticsRetentionIndexTarget(
                        type=ProductAnalyticsRetentionIndexTargetType.INDEX,
                        value=0,
                    ),
                    return_period_target=ProductAnalyticsRetentionIndexTarget(
                        type=ProductAnalyticsRetentionIndexTargetType.INDEX,
                        value=0,
                    ),
                    type=ProductAnalyticsRetentionCellScopeType.CELL,
                ),
                limit=100,
                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=ProductAnalyticsRetentionListRequestType.RETENTION_LIST_REQUEST,
    ),
)

configuration = Configuration()
configuration.unstable_operations["query_product_analytics_retention_list"] = True
with ApiClient(configuration) as api_client:
    api_instance = ProductAnalyticsApi(api_client)
    response = api_instance.query_product_analytics_retention_list(body=body)

    print(response)

Instructions

First install the library and its dependencies and then save the example to example.py and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comuk1.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" python3 "example.py"

# List the entities behind a retention cell returns "OK" response

require "datadog_api_client"
DatadogAPIClient.configure do |config|
  config.unstable_operations["v2.query_product_analytics_retention_list".to_sym] = true
end
api_instance = DatadogAPIClient::V2::ProductAnalyticsAPI.new

body = DatadogAPIClient::V2::ProductAnalyticsRetentionListRequest.new({
  data: DatadogAPIClient::V2::ProductAnalyticsRetentionListRequestData.new({
    attributes: DatadogAPIClient::V2::ProductAnalyticsRetentionListRequestAttributes.new({
      from: 1756425600000,
      query: DatadogAPIClient::V2::ProductAnalyticsRetentionListQuery.new({
        columns: [
          DatadogAPIClient::V2::ProductAnalyticsRetentionListColumn.new({
            field: DatadogAPIClient::V2::ProductAnalyticsRetentionListColumnField.new({
              path: "@usr.email",
            }),
          }),
        ],
        computation_scope: DatadogAPIClient::V2::ProductAnalyticsRetentionCellScope.new({
          cohort_target: DatadogAPIClient::V2::ProductAnalyticsRetentionIndexTarget.new({
            type: DatadogAPIClient::V2::ProductAnalyticsRetentionIndexTargetType::INDEX,
            value: 0,
          }),
          return_period_target: DatadogAPIClient::V2::ProductAnalyticsRetentionIndexTarget.new({
            type: DatadogAPIClient::V2::ProductAnalyticsRetentionIndexTargetType::INDEX,
            value: 0,
          }),
          type: DatadogAPIClient::V2::ProductAnalyticsRetentionCellScopeType::CELL,
        }),
        limit: 100,
        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::ProductAnalyticsRetentionListRequestType::RETENTION_LIST_REQUEST,
  }),
})
p api_instance.query_product_analytics_retention_list(body)

Instructions

First install the library and its dependencies and then save the example to example.rb and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comuk1.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" rb "example.rb"

// List the entities behind a retention cell 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.ProductAnalyticsRetentionListRequest{
		Data: datadogV2.ProductAnalyticsRetentionListRequestData{
			Attributes: datadogV2.ProductAnalyticsRetentionListRequestAttributes{
				From: 1756425600000,
				Query: datadogV2.ProductAnalyticsRetentionListQuery{
					Columns: []datadogV2.ProductAnalyticsRetentionListColumn{
						{
							Field: &datadogV2.ProductAnalyticsRetentionListColumnField{
								Path: datadog.PtrString("@usr.email"),
							},
						},
					},
					ComputationScope: datadogV2.ProductAnalyticsRetentionCellScope{
						CohortTarget: datadogV2.ProductAnalyticsRetentionCohortTarget{
							ProductAnalyticsRetentionIndexTarget: &datadogV2.ProductAnalyticsRetentionIndexTarget{
								Type:  datadogV2.PRODUCTANALYTICSRETENTIONINDEXTARGETTYPE_INDEX,
								Value: 0,
							}},
						ReturnPeriodTarget: datadogV2.ProductAnalyticsRetentionIndexTarget{
							Type:  datadogV2.PRODUCTANALYTICSRETENTIONINDEXTARGETTYPE_INDEX,
							Value: 0,
						},
						Type: datadogV2.PRODUCTANALYTICSRETENTIONCELLSCOPETYPE_CELL,
					},
					Limit: datadog.PtrInt64(100),
					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.PRODUCTANALYTICSRETENTIONLISTREQUESTTYPE_RETENTION_LIST_REQUEST,
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	configuration := datadog.NewConfiguration()
	configuration.SetUnstableOperationEnabled("v2.QueryProductAnalyticsRetentionList", true)
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewProductAnalyticsApi(apiClient)
	resp, r, err := api.QueryProductAnalyticsRetentionList(ctx, body)

	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ProductAnalyticsApi.QueryProductAnalyticsRetentionList`: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}

	responseContent, _ := json.MarshalIndent(resp, "", "  ")
	fmt.Fprintf(os.Stdout, "Response from `ProductAnalyticsApi.QueryProductAnalyticsRetentionList`:\n%s\n", responseContent)
}

Instructions

First install the library and its dependencies and then save the example to main.go and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comuk1.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" go run "main.go"

// List the entities behind a retention cell 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.ProductAnalyticsRetentionCalendarTimeInterval;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionCalendarTimeIntervalType;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionCellScope;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionCellScopeType;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionCohortCriteria;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionCohortTarget;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionEntity;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionFilters;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionIndexTarget;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionIndexTargetType;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionListColumn;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionListColumnField;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionListQuery;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionListRequest;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionListRequestAttributes;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionListRequestData;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionListRequestType;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionListResponse;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionReturnCondition;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionReturnCriteria;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionSearch;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionTimeInterval;
import java.util.Collections;
import java.util.UUID;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    defaultClient.setUnstableOperationEnabled("v2.queryProductAnalyticsRetentionList", true);
    ProductAnalyticsApi apiInstance = new ProductAnalyticsApi(defaultClient);

    ProductAnalyticsRetentionListRequest body =
        new ProductAnalyticsRetentionListRequest()
            .data(
                new ProductAnalyticsRetentionListRequestData()
                    .attributes(
                        new ProductAnalyticsRetentionListRequestAttributes()
                            .from(1756425600000L)
                            .query(
                                new ProductAnalyticsRetentionListQuery()
                                    .columns(
                                        Collections.singletonList(
                                            new ProductAnalyticsRetentionListColumn()
                                                .field(
                                                    new ProductAnalyticsRetentionListColumnField()
                                                        .path("@usr.email"))))
                                    .computationScope(
                                        new ProductAnalyticsRetentionCellScope()
                                            .cohortTarget(
                                                new ProductAnalyticsRetentionCohortTarget(
                                                    new ProductAnalyticsRetentionIndexTarget()
                                                        .type(
                                                            ProductAnalyticsRetentionIndexTargetType
                                                                .INDEX)
                                                        .value(0L)))
                                            .returnPeriodTarget(
                                                new ProductAnalyticsRetentionIndexTarget()
                                                    .type(
                                                        ProductAnalyticsRetentionIndexTargetType
                                                            .INDEX)
                                                    .value(0L))
                                            .type(ProductAnalyticsRetentionCellScopeType.CELL))
                                    .limit(100L)
                                    .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(ProductAnalyticsRetentionListRequestType.RETENTION_LIST_REQUEST));

    try {
      ProductAnalyticsRetentionListResponse result =
          apiInstance.queryProductAnalyticsRetentionList(body);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println(
          "Exception when calling ProductAnalyticsApi#queryProductAnalyticsRetentionList");
      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 and then save the example to Example.java and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comuk1.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" java "Example.java"

// List the entities behind a retention cell 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::ProductAnalyticsRetentionCalendarTimeInterval;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionCalendarTimeIntervalType;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionCellScope;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionCellScopeType;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionCohortCriteria;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionCohortTarget;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionEntity;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionFilters;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionIndexTarget;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionIndexTargetType;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionListColumn;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionListColumnField;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionListQuery;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionListRequest;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionListRequestAttributes;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionListRequestData;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionListRequestType;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionReturnCondition;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionReturnCriteria;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionSearch;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionTimeInterval;
use uuid::Uuid;

#[tokio::main]
async fn main() {
    let body =
        ProductAnalyticsRetentionListRequest::new(
            ProductAnalyticsRetentionListRequestData::new(
                ProductAnalyticsRetentionListRequestAttributes::new(
                    1756425600000,
                    ProductAnalyticsRetentionListQuery::new(
                        ProductAnalyticsRetentionCellScope::new(
                            ProductAnalyticsRetentionCohortTarget::ProductAnalyticsRetentionIndexTarget(
                                Box::new(
                                    ProductAnalyticsRetentionIndexTarget::new(
                                        ProductAnalyticsRetentionIndexTargetType::INDEX,
                                        0,
                                    ),
                                ),
                            ),
                            ProductAnalyticsRetentionIndexTarget::new(
                                ProductAnalyticsRetentionIndexTargetType::INDEX,
                                0,
                            ),
                            ProductAnalyticsRetentionCellScopeType::CELL,
                        ),
                        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()),
                                            ),
                                        ),
                                    ),
                                ),
                            ),
                    )
                        .columns(
                            vec![
                                ProductAnalyticsRetentionListColumn
                                ::new().field(
                                    ProductAnalyticsRetentionListColumnField::new().path("@usr.email".to_string()),
                                )
                            ],
                        )
                        .limit(100),
                    1756857600000,
                ),
                ProductAnalyticsRetentionListRequestType::RETENTION_LIST_REQUEST,
            ),
        );
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.QueryProductAnalyticsRetentionList", true);
    let api = ProductAnalyticsAPI::with_config(configuration);
    let resp = api.query_product_analytics_retention_list(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

Instructions

First install the library and its dependencies and then save the example to src/main.rs and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comuk1.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" cargo run

/**
 * List the entities behind a retention cell returns "OK" response
 */

import { client, v2 } from "@datadog/datadog-api-client";

const configuration = client.createConfiguration();
configuration.unstableOperations["v2.queryProductAnalyticsRetentionList"] =
  true;
const apiInstance = new v2.ProductAnalyticsApi(configuration);

const params: v2.ProductAnalyticsApiQueryProductAnalyticsRetentionListRequest =
  {
    body: {
      data: {
        attributes: {
          from: 1756425600000,
          query: {
            columns: [
              {
                field: {
                  path: "@usr.email",
                },
              },
            ],
            computationScope: {
              cohortTarget: {
                type: "index",
                value: 0,
              },
              returnPeriodTarget: {
                type: "index",
                value: 0,
              },
              type: "cell",
            },
            limit: 100,
            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_list_request",
      },
    },
  };

apiInstance
  .queryProductAnalyticsRetentionList(params)
  .then((data: v2.ProductAnalyticsRetentionListResponse) => {
    console.log(
      "API called successfully. Returned data: " + JSON.stringify(data)
    );
  })
  .catch((error: any) => console.error(error));

Instructions

First install the library and its dependencies and then save the example to example.ts and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comuk1.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" tsc "example.ts"

List the entities behind a retention cell

Overview

Request

Body Data (required)

Response

Code Example

List the entities behind a retention cell

List the entities behind a retention cell

Instructions

List the entities behind a retention cell

Instructions

List the entities behind a retention cell

Instructions

List the entities behind a retention cell

Instructions

List the entities behind a retention cell

Instructions

List the entities behind a retention cell

Instructions

How can I help you today?