---
title: Crear una métrica basada en rum
description: Crea una métrica basada en los datos de RUM de tu organización.
breadcrumbs: Documentación > API > Crear una métrica basada en rum
---

> For the complete documentation index, see [llms.txt](https://dnd37xeb23o8n.cloudfront.net/stefon.simmons/docs-astro-web-10435/llms.txt).

# Crear una métrica basada en rum

## v2 (latest)

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

### Overview

Crea una métrica basada en los datos de RUM de tu organización.
Devuelve el objeto de métrica basada en rum del cuerpo de la solicitud cuando dicha solicitud es satisfactoria.

### Request

#### Body Data (required)

La definición de la nueva métrica basada en rum.

{% tabs %}
{% tab label="Model" %}
| Parent field | Field                         | Type     | Description                                                                                                                                     |
| ------------ | ----------------------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
|              | data [*required*]             | object   | El nuevo cuerpo métrica basada en rum.                                                                                                          |
| data         | attributes [*required*]       | object   | The object describing the Datadog RUM-based metric to create.                                                                                   |
| attributes   | compute [*required*]          | object   | The compute rule to compute the RUM-based metric.                                                                                               |
| compute      | aggregation_type [*required*] | enum     | The type of aggregation to use. Allowed enum values: `count`, `distribution`.                                                                   |
| compute      | include_percentiles           | boolean  | Toggle to include or exclude percentile aggregations for distribution metrics. Only present when `aggregation_type` is `distribution`.          |
| compute      | path                          | string   | The path to the value the RUM-based metric will aggregate on. Only present when `aggregation_type` is `distribution`.                           |
| attributes   | event_type [*required*]       | enum     | The type of RUM events to filter on. Allowed enum values: `session`, `view`, `action`, `error`, `resource`, `long_task`, `vital`.               |
| attributes   | filter                        | object   | The RUM-based metric filter. Events matching this filter will be aggregated in this metric.                                                     |
| filter       | query [*required*]            | string   | The search query - following the RUM search syntax. Default: `*`.                                                                               |
| attributes   | group_by                      | [object] | The rules for the group by.                                                                                                                     |
| group_by     | path [*required*]             | string   | The path to the value the RUM-based metric will be aggregated over.                                                                             |
| group_by     | tag_name                      | string   | Eventual name of the tag that gets created. By default, `path` is used as the tag name.                                                         |
| attributes   | uniqueness                    | object   | The rule to count updatable events. Is only set if `event_type` is `sessions` or `views`.                                                       |
| uniqueness   | when [*required*]             | enum     | When to count updatable events. `match` when the event is first seen, or `end` when the event is complete. Allowed enum values: `match`, `end`. |
| data         | id [*required*]               | string   | The name of the RUM-based metric.                                                                                                               |
| data         | type [*required*]             | enum     | The type of the resource. The value should always 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-ui"
      },
      "group_by": [
        {
          "path": "@browser.name",
          "tag_name": "browser_name"
        }
      ],
      "uniqueness": {
        "when": "match"
      }
    },
    "id": "examplerummetric",
    "type": "rum_metrics"
  }
}
```
{% /tab %}
{% /tabs %}

### Response

{% tabs %}
{% tab label="201" %}
Created

{% tabs %}
{% tab label="Model" %}
The RUM-based metric object.

| Parent field | Field               | Type     | Description                                                                                                                                     |
| ------------ | ------------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
|              | data                | object   | The RUM-based metric properties.                                                                                                                |
| data         | attributes          | object   | The object describing a Datadog RUM-based metric.                                                                                               |
| attributes   | compute             | object   | The compute rule to compute the RUM-based metric.                                                                                               |
| compute      | aggregation_type    | enum     | The type of aggregation to use. Allowed enum values: `count`, `distribution`.                                                                   |
| compute      | include_percentiles | boolean  | Toggle to include or exclude percentile aggregations for distribution metrics. Only present when `aggregation_type` is `distribution`.          |
| compute      | path                | string   | The path to the value the RUM-based metric will aggregate on. Only present when `aggregation_type` is `distribution`.                           |
| attributes   | event_type          | enum     | The type of RUM events to filter on. Allowed enum values: `session`, `view`, `action`, `error`, `resource`, `long_task`, `vital`.               |
| attributes   | filter              | object   | The RUM-based metric filter. RUM events matching this filter will be aggregated in this metric.                                                 |
| filter       | query               | string   | The search query - following the RUM search syntax.                                                                                             |
| attributes   | group_by            | [object] | The rules for the group by.                                                                                                                     |
| group_by     | path                | string   | The path to the value the RUM-based metric will be aggregated over.                                                                             |
| group_by     | tag_name            | string   | Eventual name of the tag that gets created. By default, `path` is used as the tag name.                                                         |
| attributes   | uniqueness          | object   | The rule to count updatable events. Is only set if `event_type` is `session` or `view`.                                                         |
| uniqueness   | when                | enum     | When to count updatable events. `match` when the event is first seen, or `end` when the event is complete. Allowed enum values: `match`, `end`. |
| data         | id                  | string   | The name of the RUM-based metric.                                                                                                               |
| data         | type                | enum     | The type of the resource. The value should always 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="400" %}
Bad Request

{% 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="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="409" %}
Conflict

{% 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 POST "https://api.${DD_SITE}/api/v2/rum/config/metrics" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "compute": {
        "aggregation_type": "distribution",
        "include_percentiles": true,
        "path": "@duration"
      },
      "event_type": "session",
      "filter": {
        "query": "@service:web-ui"
      },
      "group_by": [
        {
          "path": "@browser.name",
          "tag_name": "browser_name"
        }
      ],
      "uniqueness": {
        "when": "match"
      }
    },
    "id": "examplerummetric",
    "type": "rum_metrics"
  }
}
EOF
```
{% /tab %}

{% tab label="Go" %}
```go
// Create a RUM-based metric returns "Created" 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() {
	body := datadogV2.RumMetricCreateRequest{
		Data: datadogV2.RumMetricCreateData{
			Attributes: datadogV2.RumMetricCreateAttributes{
				Compute: datadogV2.RumMetricCompute{
					AggregationType:    datadogV2.RUMMETRICCOMPUTEAGGREGATIONTYPE_DISTRIBUTION,
					IncludePercentiles: datadog.PtrBool(true),
					Path:               datadog.PtrString("@duration"),
				},
				EventType: datadogV2.RUMMETRICEVENTTYPE_SESSION,
				Filter: &datadogV2.RumMetricFilter{
					Query: "@service:web-ui",
				},
				GroupBy: []datadogV2.RumMetricGroupBy{
					{
						Path:    "@browser.name",
						TagName: datadog.PtrString("browser_name"),
					},
				},
				Uniqueness: &datadogV2.RumMetricUniqueness{
					When: datadogV2.RUMMETRICUNIQUENESSWHEN_WHEN_MATCH,
				},
			},
			Id:   "examplerummetric",
			Type: datadogV2.RUMMETRICTYPE_RUM_METRICS,
		},
	}
	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.CreateRumMetric(ctx, body)

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

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

#### Instructions

First [install the library and its dependencies](https://dnd37xeb23o8n.cloudfront.net/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
// Create a RUM-based metric returns "Created" 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.RumMetricCompute;
import com.datadog.api.client.v2.model.RumMetricComputeAggregationType;
import com.datadog.api.client.v2.model.RumMetricCreateAttributes;
import com.datadog.api.client.v2.model.RumMetricCreateData;
import com.datadog.api.client.v2.model.RumMetricCreateRequest;
import com.datadog.api.client.v2.model.RumMetricEventType;
import com.datadog.api.client.v2.model.RumMetricFilter;
import com.datadog.api.client.v2.model.RumMetricGroupBy;
import com.datadog.api.client.v2.model.RumMetricResponse;
import com.datadog.api.client.v2.model.RumMetricType;
import com.datadog.api.client.v2.model.RumMetricUniqueness;
import com.datadog.api.client.v2.model.RumMetricUniquenessWhen;
import java.util.Collections;

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

    RumMetricCreateRequest body =
        new RumMetricCreateRequest()
            .data(
                new RumMetricCreateData()
                    .attributes(
                        new RumMetricCreateAttributes()
                            .compute(
                                new RumMetricCompute()
                                    .aggregationType(RumMetricComputeAggregationType.DISTRIBUTION)
                                    .includePercentiles(true)
                                    .path("@duration"))
                            .eventType(RumMetricEventType.SESSION)
                            .filter(new RumMetricFilter().query("@service:web-ui"))
                            .groupBy(
                                Collections.singletonList(
                                    new RumMetricGroupBy()
                                        .path("@browser.name")
                                        .tagName("browser_name")))
                            .uniqueness(
                                new RumMetricUniqueness().when(RumMetricUniquenessWhen.WHEN_MATCH)))
                    .id("examplerummetric")
                    .type(RumMetricType.RUM_METRICS));

    try {
      RumMetricResponse result = apiInstance.createRumMetric(body);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling RumMetricsApi#createRumMetric");
      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://dnd37xeb23o8n.cloudfront.net/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
"""
Create a RUM-based metric returns "Created" response
"""

from os import environ
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.rum_metrics_api import RumMetricsApi
from datadog_api_client.v2.model.rum_metric_compute import RumMetricCompute
from datadog_api_client.v2.model.rum_metric_compute_aggregation_type import RumMetricComputeAggregationType
from datadog_api_client.v2.model.rum_metric_create_attributes import RumMetricCreateAttributes
from datadog_api_client.v2.model.rum_metric_create_data import RumMetricCreateData
from datadog_api_client.v2.model.rum_metric_create_request import RumMetricCreateRequest
from datadog_api_client.v2.model.rum_metric_event_type import RumMetricEventType
from datadog_api_client.v2.model.rum_metric_filter import RumMetricFilter
from datadog_api_client.v2.model.rum_metric_group_by import RumMetricGroupBy
from datadog_api_client.v2.model.rum_metric_type import RumMetricType
from datadog_api_client.v2.model.rum_metric_uniqueness import RumMetricUniqueness
from datadog_api_client.v2.model.rum_metric_uniqueness_when import RumMetricUniquenessWhen

body = RumMetricCreateRequest(
    data=RumMetricCreateData(
        attributes=RumMetricCreateAttributes(
            compute=RumMetricCompute(
                aggregation_type=RumMetricComputeAggregationType.DISTRIBUTION,
                include_percentiles=True,
                path="@duration",
            ),
            event_type=RumMetricEventType.SESSION,
            filter=RumMetricFilter(
                query="@service:web-ui",
            ),
            group_by=[
                RumMetricGroupBy(
                    path="@browser.name",
                    tag_name="browser_name",
                ),
            ],
            uniqueness=RumMetricUniqueness(
                when=RumMetricUniquenessWhen.WHEN_MATCH,
            ),
        ),
        id="examplerummetric",
        type=RumMetricType.RUM_METRICS,
    ),
)

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

    print(response)
```

#### Instructions

First [install the library and its dependencies](https://dnd37xeb23o8n.cloudfront.net/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
# Create a RUM-based metric returns "Created" response

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

body = DatadogAPIClient::V2::RumMetricCreateRequest.new({
  data: DatadogAPIClient::V2::RumMetricCreateData.new({
    attributes: DatadogAPIClient::V2::RumMetricCreateAttributes.new({
      compute: DatadogAPIClient::V2::RumMetricCompute.new({
        aggregation_type: DatadogAPIClient::V2::RumMetricComputeAggregationType::DISTRIBUTION,
        include_percentiles: true,
        path: "@duration",
      }),
      event_type: DatadogAPIClient::V2::RumMetricEventType::SESSION,
      filter: DatadogAPIClient::V2::RumMetricFilter.new({
        query: "@service:web-ui",
      }),
      group_by: [
        DatadogAPIClient::V2::RumMetricGroupBy.new({
          path: "@browser.name",
          tag_name: "browser_name",
        }),
      ],
      uniqueness: DatadogAPIClient::V2::RumMetricUniqueness.new({
        _when: DatadogAPIClient::V2::RumMetricUniquenessWhen::WHEN_MATCH,
      }),
    }),
    id: "examplerummetric",
    type: DatadogAPIClient::V2::RumMetricType::RUM_METRICS,
  }),
})
p api_instance.create_rum_metric(body)
```

#### Instructions

First [install the library and its dependencies](https://dnd37xeb23o8n.cloudfront.net/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>" rb "example.rb"
```
{% /tab %}

{% tab label="Rust" %}
```rust
// Create a RUM-based metric returns "Created" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_rum_metrics::RumMetricsAPI;
use datadog_api_client::datadogV2::model::RumMetricCompute;
use datadog_api_client::datadogV2::model::RumMetricComputeAggregationType;
use datadog_api_client::datadogV2::model::RumMetricCreateAttributes;
use datadog_api_client::datadogV2::model::RumMetricCreateData;
use datadog_api_client::datadogV2::model::RumMetricCreateRequest;
use datadog_api_client::datadogV2::model::RumMetricEventType;
use datadog_api_client::datadogV2::model::RumMetricFilter;
use datadog_api_client::datadogV2::model::RumMetricGroupBy;
use datadog_api_client::datadogV2::model::RumMetricType;
use datadog_api_client::datadogV2::model::RumMetricUniqueness;
use datadog_api_client::datadogV2::model::RumMetricUniquenessWhen;

#[tokio::main]
async fn main() {
    let body = RumMetricCreateRequest::new(RumMetricCreateData::new(
        RumMetricCreateAttributes::new(
            RumMetricCompute::new(RumMetricComputeAggregationType::DISTRIBUTION)
                .include_percentiles(true)
                .path("@duration".to_string()),
            RumMetricEventType::SESSION,
        )
        .filter(RumMetricFilter::new("@service:web-ui".to_string()))
        .group_by(vec![
            RumMetricGroupBy::new("@browser.name".to_string()).tag_name("browser_name".to_string())
        ])
        .uniqueness(RumMetricUniqueness::new(
            RumMetricUniquenessWhen::WHEN_MATCH,
        )),
        "examplerummetric".to_string(),
        RumMetricType::RUM_METRICS,
    ));
    let configuration = datadog::Configuration::new();
    let api = RumMetricsAPI::with_config(configuration);
    let resp = api.create_rum_metric(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}
```

#### Instructions

First [install the library and its dependencies](https://dnd37xeb23o8n.cloudfront.net/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
/**
 * Create a RUM-based metric returns "Created" 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);

const params: v2.RumMetricsApiCreateRumMetricRequest = {
  body: {
    data: {
      attributes: {
        compute: {
          aggregationType: "distribution",
          includePercentiles: true,
          path: "@duration",
        },
        eventType: "session",
        filter: {
          query: "@service:web-ui",
        },
        groupBy: [
          {
            path: "@browser.name",
            tagName: "browser_name",
          },
        ],
        uniqueness: {
          when: "match",
        },
      },
      id: "examplerummetric",
      type: "rum_metrics",
    },
  },
};

apiInstance
  .createRumMetric(params)
  .then((data: v2.RumMetricResponse) => {
    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://dnd37xeb23o8n.cloudfront.net/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>" tsc "example.ts"
```
{% /tab %}
{% /tabs %}