---
title: Get all RUM-based metrics
description: Get the list of all RUM-based metrics configured for your organization, with their definitions.
breadcrumbs: Docs > API > Get all RUM-based metrics
---

> For the complete documentation index, see [llms.txt](https://docs.datadoghq.com/llms.txt).

# Get all RUM-based metrics

## v2 (latest)

| Datadog site      | API endpoint                                                |
| ----------------- | ----------------------------------------------------------- |
| app.datadoghq.com | GET https://api.datadoghq.com/api/v2/rum/config/metrics     |
| us3.datadoghq.com | GET https://api.us3.datadoghq.com/api/v2/rum/config/metrics |
| us5.datadoghq.com | GET https://api.us5.datadoghq.com/api/v2/rum/config/metrics |
| app.datadoghq.eu  | GET https://api.datadoghq.eu/api/v2/rum/config/metrics      |
| ap1.datadoghq.com | GET https://api.ap1.datadoghq.com/api/v2/rum/config/metrics |
| ap2.datadoghq.com | GET https://api.ap2.datadoghq.com/api/v2/rum/config/metrics |
| uk1.datadoghq.com | GET https://api.uk1.datadoghq.com/api/v2/rum/config/metrics |
| app.ddog-gov.com  | GET https://api.ddog-gov.com/api/v2/rum/config/metrics      |
| us2.ddog-gov.com  | GET https://api.us2.ddog-gov.com/api/v2/rum/config/metrics  |

### Overview

Get the list of all RUM-based metrics configured for your organization, with their definitions.
The list is not paginated.
Metrics whose stored definition cannot be converted to the RUM format are omitted from the list.
To retrieve a single metric, use `GetRumMetric`.

This endpoint requires the `rum_apps_read` permission.

### Response

{% tabs %}
{% tab label="200" %}
OK

{% tabs %}
{% tab label="Model" %}
All the available RUM-based metric objects.

| Parent field | Field               | Type     | Description                                                                                                                                                                                                                                                        |
| ------------ | ------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
|              | data                | [object] | A list of RUM-based metric objects.                                                                                                                                                                                                                                |
| data         | attributes          | object   | The object describing a Datadog RUM-based metric.                                                                                                                                                                                                                  |
| attributes   | compute             | object   | The compute rule of the RUM-based metric.                                                                                                                                                                                                                          |
| compute      | aggregation_type    | enum     | The type of aggregation to use. `count` counts the matching events. `distribution` aggregates the values found at `path`. Allowed enum values: `count`, `distribution`.                                                                                            |
| compute      | include_percentiles | boolean  | Toggle to include or exclude percentile aggregations (p50, p75, p90, p95, p99) for distribution metrics. Required when `aggregation_type` is `distribution`, and must be omitted otherwise.                                                                        |
| compute      | path                | string   | The path of the numeric RUM event attribute the metric aggregates on. Only present when `aggregation_type` is `distribution`.                                                                                                                                      |
| attributes   | event_type          | enum     | The type of RUM events the metric is generated from. It is set at creation and cannot be changed. Allowed enum values: `session`, `view`, `action`, `error`, `resource`, `long_task`, `vital`.                                                                     |
| attributes   | filter              | object   | The RUM-based metric filter. RUM events matching this filter are aggregated in this metric. Omitted if the metric only filters on the event type.                                                                                                                  |
| filter       | query               | string   | The search query, following the [RUM search syntax](https://docs.datadoghq.com/real_user_monitoring/explorer/search_syntax.md). It does not include the event type filter.                                                                                         |
| attributes   | group_by            | [object] | The rules the metric is grouped by. An empty array is returned if the metric is not grouped.                                                                                                                                                                       |
| group_by     | path                | string   | The path of the RUM event attribute the metric is grouped by.                                                                                                                                                                                                      |
| group_by     | tag_name            | string   | Name of the tag created on the metric. By default, `path` is used as the tag name.                                                                                                                                                                                 |
| attributes   | uniqueness          | object   | The rule to count updatable events. Only present if `event_type` is `session` or `view`, and absent on older metrics created before this setting existed.                                                                                                          |
| uniqueness   | when                | enum     | When to count updatable events. `match` when the event is first seen, or `end` when the event is complete. Sessions and views are updated over time, and each one is counted once. Allowed enum values: `match`, `end`.                                            |
| data         | id                  | string   | The name of the RUM-based metric. On creation, it must be 1 to 200 characters long, contain only ASCII letters, digits, underscores, and periods, start with a letter, and not start with `rum.measure` or `rum.investigate`. It cannot be changed after creation. |
| data         | type                | enum     | The type of the resource. The value must be `rum_metrics`. Allowed enum values: `rum_metrics`. Default: `rum_metrics`.                                                                                                                                             |
{% /tab %}

{% tab label="Example" %}
```json
{
  "data": [
    {
      "attributes": {
        "compute": {
          "aggregation_type": "distribution",
          "include_percentiles": true,
          "path": "@duration"
        },
        "event_type": "session",
        "filter": {
          "query": "service:web* AND @http.status_code:[200 TO 299]"
        },
        "group_by": [
          {
            "path": "@http.status_code",
            "tag_name": "status_code"
          }
        ],
        "uniqueness": {
          "when": "match"
        }
      },
      "id": "rum.sessions.webui.count",
      "type": "rum_metrics"
    }
  ]
}
```
{% /tab %}
{% /tabs %}
{% /tab %}

{% tab label="403" %}
Not Authorized

{% tabs %}
{% tab label="Model" %}
API error response.

| Field               | Type     | Description       |
| ------------------- | -------- | ----------------- |
| errors [*required*] | [string] | A list of errors. |
{% /tab %}

{% tab label="Example" %}
```json
{
  "errors": [
    "Bad Request"
  ]
}
```
{% /tab %}
{% /tabs %}
{% /tab %}

{% tab label="429" %}
Too many requests

{% tabs %}
{% tab label="Model" %}
API error response.

| Field               | Type     | Description       |
| ------------------- | -------- | ----------------- |
| errors [*required*] | [string] | A list of errors. |
{% /tab %}

{% tab label="Example" %}
```json
{
  "errors": [
    "Bad Request"
  ]
}
```
{% /tab %}
{% /tabs %}
{% /tab %}
{% /tabs %}

### Code Example

{% tabs %}
{% tab label="Curl" %}
```bash
# Set your Datadog site and credentials
export DD_SITE="datadoghq.com" # Or us3.datadoghq.com, us5.datadoghq.com, datadoghq.eu, ap1.datadoghq.com, ap2.datadoghq.com, uk1.datadoghq.com, ddog-gov.com, us2.ddog-gov.com
# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

curl -X GET "https://api.${DD_SITE}/api/v2/rum/config/metrics" \
-H "Accept: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}"
```
{% /tab %}

{% tab label="Go" %}
```go
// Get all RUM-based metrics 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"
)

func main() {
	ctx := datadog.NewDefaultContext(context.Background())
	ctx = context.WithValue(ctx, datadog.ContextAccessToken, os.Getenv("DD_BEARER_TOKEN"))
	configuration := datadog.NewConfiguration()
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewRumMetricsApi(apiClient)
	resp, r, err := api.ListRumMetrics(ctx)

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

	responseContent, _ := json.MarshalIndent(resp, "", "  ")
	fmt.Fprintf(os.Stdout, "Response from `RumMetricsApi.ListRumMetrics`:\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:

```bash
DD_SITE="datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" go run "main.go"
```
{% /tab %}

{% tab label="Java" %}
```java
// Get all RUM-based metrics returns "OK" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.RumMetricsApi;
import com.datadog.api.client.v2.model.RumMetricsResponse;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    defaultClient.setAccessToken(System.getenv("DD_BEARER_TOKEN"));
    RumMetricsApi apiInstance = new RumMetricsApi(defaultClient);

    try {
      RumMetricsResponse result = apiInstance.listRumMetrics();
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling RumMetricsApi#listRumMetrics");
      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:

```bash
DD_SITE="datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" java "Example.java"
```
{% /tab %}

{% tab label="Python" %}
```python
"""
Get all RUM-based metrics returns "OK" response
"""

from os import environ
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.rum_metrics_api import RumMetricsApi

configuration = Configuration()
configuration.access_token = environ["DD_BEARER_TOKEN"]
with ApiClient(configuration) as api_client:
    api_instance = RumMetricsApi(api_client)
    response = api_instance.list_rum_metrics()

    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:

```bash
DD_SITE="datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" python3 "example.py"
```
{% /tab %}

{% tab label="Ruby" %}
```ruby
# Get all RUM-based metrics returns "OK" response

require "datadog_api_client"
DatadogAPIClient.configure do |config|
  config.access_token = ENV["DD_BEARER_TOKEN"]
end
api_instance = DatadogAPIClient::V2::RumMetricsAPI.new
p api_instance.list_rum_metrics()
```

#### 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:

```bash
DD_SITE="datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" ruby "example.rb"
```
{% /tab %}

{% tab label="Rust" %}
```rust
// Get all RUM-based metrics returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_rum_metrics::RumMetricsAPI;

#[tokio::main]
async fn main() {
    let configuration = datadog::Configuration::new();
    let api = RumMetricsAPI::with_config(configuration);
    let resp = api.list_rum_metrics().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:

```bash
DD_SITE="datadoghq.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" cargo run
```
{% /tab %}

{% tab label="TypeScript" %}
```typescript
/**
 * Get all RUM-based metrics returns "OK" response
 */

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

const configuration = client.createConfiguration({
  authMethods: {
    AuthZ: {
      accessToken: process.env.DD_BEARER_TOKEN as string,
    },
  },
});
const apiInstance = new v2.RumMetricsApi(configuration);

apiInstance
  .listRumMetrics()
  .then((data: v2.RumMetricsResponse) => {
    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:

```bash
DD_SITE="datadoghq.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" npx tsx "example.ts"
```
{% /tab %}
{% /tabs %}