---
title: Update a RUM application
description: Update the RUM application with given ID in your organization.
breadcrumbs: Docs > API > Update a RUM application
---

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

# Update a RUM application

## v2 (latest)

| Datadog site      | API endpoint                                                     |
| ----------------- | ---------------------------------------------------------------- |
| app.datadoghq.com | PATCH https://api.datadoghq.com/api/v2/rum/applications/{id}     |
| us3.datadoghq.com | PATCH https://api.us3.datadoghq.com/api/v2/rum/applications/{id} |
| us5.datadoghq.com | PATCH https://api.us5.datadoghq.com/api/v2/rum/applications/{id} |
| app.datadoghq.eu  | PATCH https://api.datadoghq.eu/api/v2/rum/applications/{id}      |
| ap1.datadoghq.com | PATCH https://api.ap1.datadoghq.com/api/v2/rum/applications/{id} |
| ap2.datadoghq.com | PATCH https://api.ap2.datadoghq.com/api/v2/rum/applications/{id} |
| uk1.datadoghq.com | PATCH https://api.uk1.datadoghq.com/api/v2/rum/applications/{id} |
| app.ddog-gov.com  | PATCH https://api.ddog-gov.com/api/v2/rum/applications/{id}      |
| us2.ddog-gov.com  | PATCH https://api.us2.ddog-gov.com/api/v2/rum/applications/{id}  |

### Overview

Update the RUM application with given ID in your organization.

This endpoint requires the `rum_apps_write` permission.

### Arguments

#### Path Parameters

| Field           | Type   | Description         |
| --------------- | ------ | ------------------- |
| id [*required*] | string | RUM application ID. |

### Request

#### Body Data (required)

{% tabs %}
{% tab label="Model" %}
| Parent field | Field                             | Type   | Description                                                                                                                                                    |
| ------------ | --------------------------------- | ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|              | data [*required*]                 | object | RUM application update.                                                                                                                                        |
| data         | attributes                        | object | RUM application update attributes.                                                                                                                             |
| attributes   | name                              | string | Name of the RUM application.                                                                                                                                   |
| attributes   | product_analytics_retention_state | enum   | Controls the retention policy for Product Analytics data derived from RUM events. Allowed enum values: `MAX`, `NONE`.                                          |
| attributes   | rum_event_processing_state        | enum   | Configures which RUM events are processed and stored for the application. Allowed enum values: `ALL`, `ERROR_FOCUSED_MODE`, `NONE`.                            |
| attributes   | type                              | string | Type of the RUM application. Supported values are `browser`, `ios`, `android`, `react-native`, `flutter`, `roku`, `electron`, `unity`, `kotlin-multiplatform`. |
| data         | id [*required*]                   | string | RUM application ID.                                                                                                                                            |
| data         | type [*required*]                 | enum   | RUM application update type. Allowed enum values: `rum_application_update`. Default: `rum_application_update`.                                                 |
{% /tab %}

{% tab label="Example" %}
**Update a RUM application returns "OK" response**

```json
{
  "data": {
    "attributes": {
      "name": "updated_name_for_my_existing_rum_application",
      "type": "browser"
    },
    "id": "abcd1234-0000-0000-abcd-1234abcd5678",
    "type": "rum_application_update"
  }
}
```

**Update a RUM application with Product Scales returns "OK" response**

```json
{
  "data": {
    "attributes": {
      "name": "updated_rum_with_product_scales",
      "rum_event_processing_state": "ALL",
      "product_analytics_retention_state": "MAX"
    },
    "id": "abcd1234-0000-0000-abcd-1234abcd5678",
    "type": "rum_application_update"
  }
}
```
{% /tab %}
{% /tabs %}

### Response

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

{% tabs %}
{% tab label="Model" %}
RUM application response.

| Parent field                      | Field                                    | Type     | Description                                                                                                                                                              |
| --------------------------------- | ---------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
|                                   | data                                     | object   | RUM application.                                                                                                                                                         |
| data                              | attributes [*required*]                  | object   | RUM application attributes.                                                                                                                                              |
| attributes                        | api_key_id                               | int32    | ID of the API key associated with the application.                                                                                                                       |
| attributes                        | apm_rum_flat_sampling_replay_enabled     | boolean  | Indicates if flat sampling of Session Replay for APM-correlated RUM sessions is enabled.                                                                                 |
| attributes                        | apm_rum_flat_sampling_replay_sample_rate | double   | Sample rate (0-100) of Session Replay for APM-correlated RUM sessions when flat sampling is enabled.                                                                     |
| attributes                        | application_id [*required*]              | string   | ID of the RUM application.                                                                                                                                               |
| attributes                        | client_token [*required*]                | string   | Client token of the RUM application.                                                                                                                                     |
| attributes                        | created_at [*required*]                  | int64    | Timestamp in ms of the creation date.                                                                                                                                    |
| attributes                        | created_by_handle [*required*]           | string   | Handle of the creator user.                                                                                                                                              |
| attributes                        | disabled_at                              | int64    | Timestamp in ms of the date the RUM application was disabled. Only present if the application was disabled.                                                              |
| attributes                        | disabled_by_handle                       | string   | Handle of the user who disabled the RUM application. Only present if the application was disabled.                                                                       |
| attributes                        | error_tracking_exclusion_filter_enabled  | boolean  | Indicates if Error Tracking exclusion filters are enabled for the application.                                                                                           |
| attributes                        | external_feeds                           | [string] | Non-native ingestion paths the RUM application sends its data through. `otel` means the application sends RUM data through OpenTelemetry instead of the Datadog RUM SDK. |
| attributes                        | hash                                     | string   | Hash of the RUM application. Optional.                                                                                                                                   |
| attributes                        | is_active                                | boolean  | Indicates if the RUM application is active.                                                                                                                              |
| attributes                        | name [*required*]                        | string   | Name of the RUM application.                                                                                                                                             |
| attributes                        | ootb_metrics_installed                   | boolean  | Indicates if the out-of-the-box RUM metrics are installed for the application.                                                                                           |
| attributes                        | org_id [*required*]                      | int32    | Org ID of the RUM application.                                                                                                                                           |
| attributes                        | product_analytics_preview_disabled       | boolean  | Indicates that the Product Analytics preview is disabled for the application. Only present (and `true`) when the Product Analytics retention state is not preview.       |
| attributes                        | product_analytics_replay_sample_rate     | int32    | Sample rate (0-100) of Session Replay for Product Analytics sessions.                                                                                                    |
| attributes                        | product_scales                           | object   | Product Scales configuration for the RUM application.                                                                                                                    |
| product_scales                    | product_analytics_retention_scale        | object   | Product Analytics retention scale configuration.                                                                                                                         |
| product_analytics_retention_scale | last_modified_at                         | int64    | Timestamp in milliseconds when this scale was last modified.                                                                                                             |
| product_analytics_retention_scale | state                                    | enum     | Controls the retention policy for Product Analytics data derived from RUM events. Allowed enum values: `MAX`, `NONE`.                                                    |
| product_scales                    | rum_event_processing_scale               | object   | RUM event processing scale configuration.                                                                                                                                |
| rum_event_processing_scale        | last_modified_at                         | int64    | Timestamp in milliseconds when this scale was last modified.                                                                                                             |
| rum_event_processing_scale        | state                                    | enum     | Configures which RUM events are processed and stored for the application. Allowed enum values: `ALL`, `ERROR_FOCUSED_MODE`, `NONE`.                                      |
| attributes                        | remote_config_id                         | string   | ID of the RUM SDK remote configuration for the application, if one exists.                                                                                               |
| attributes                        | short_name                               | string   | Short name of the RUM application.                                                                                                                                       |
| attributes                        | tags                                     | [string] | List of tags associated with the RUM application.                                                                                                                        |
| attributes                        | type [*required*]                        | string   | Type of the RUM application. Supported values are `browser`, `ios`, `android`, `react-native`, `flutter`, `roku`, `electron`, `unity`, `kotlin-multiplatform`.           |
| attributes                        | updated_at [*required*]                  | int64    | Timestamp in ms of the last update date.                                                                                                                                 |
| attributes                        | updated_by_handle [*required*]           | string   | Handle of the updater user.                                                                                                                                              |
| data                              | id [*required*]                          | string   | RUM application ID.                                                                                                                                                      |
| data                              | type [*required*]                        | enum     | RUM application response type. Allowed enum values: `rum_application`. Default: `rum_application`.                                                                       |
{% /tab %}

{% tab label="Example" %}
```json
{
  "data": {
    "attributes": {
      "api_key_id": 123456789,
      "apm_rum_flat_sampling_replay_enabled": false,
      "apm_rum_flat_sampling_replay_sample_rate": 0,
      "application_id": "abcd1234-0000-0000-abcd-1234abcd5678",
      "client_token": "abcd1234efgh5678ijkl90abcd1234efgh0",
      "created_at": 1659479836169,
      "created_by_handle": "john.doe",
      "disabled_at": 1659479836169,
      "disabled_by_handle": "jane.doe",
      "error_tracking_exclusion_filter_enabled": false,
      "external_feeds": [
        "otel"
      ],
      "hash": "string",
      "is_active": true,
      "name": "my_rum_application",
      "ootb_metrics_installed": true,
      "org_id": 999,
      "product_analytics_preview_disabled": true,
      "product_analytics_replay_sample_rate": 0,
      "product_scales": {
        "product_analytics_retention_scale": {
          "last_modified_at": 1747922145974,
          "state": "MAX"
        },
        "rum_event_processing_scale": {
          "last_modified_at": 1721897494108,
          "state": "ALL"
        }
      },
      "remote_config_id": "abc12345-1234-5678-abcd-ef1234567890",
      "short_name": "my_rum_application",
      "tags": [
        "team:rum"
      ],
      "type": "browser",
      "updated_at": 1659479836169,
      "updated_by_handle": "jane.doe"
    },
    "id": "abcd1234-0000-0000-abcd-1234abcd5678",
    "type": "rum_application"
  }
}
```
{% /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="404" %}
Not Found

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

| Parent field | Field               | Type     | Description                                                                     |
| ------------ | ------------------- | -------- | ------------------------------------------------------------------------------- |
|              | errors [*required*] | [object] | A list of errors.                                                               |
| errors       | code                | string   | An application-specific error code.                                             |
| errors       | detail              | string   | A human-readable explanation specific to this occurrence of the error.          |
| errors       | meta                | object   | Non-standard meta-information about the error                                   |
| errors       | source              | object   | References to the source of the error.                                          |
| source       | header              | string   | A string indicating the name of a single request header which caused the error. |
| source       | parameter           | string   | A string indicating which URI query parameter caused the error.                 |
| source       | pointer             | string   | A JSON pointer to the value in the request document that caused the error.      |
| errors       | status              | string   | Status code of the response.                                                    |
| errors       | title               | string   | Short human-readable summary of the error.                                      |
{% /tab %}

{% tab label="Example" %}
```json
{
  "errors": [
    {
      "code": "invalid_request",
      "detail": "Missing required attribute in body",
      "meta": {},
      "source": {
        "header": "Authorization",
        "parameter": "limit",
        "pointer": "/data/attributes/title"
      },
      "status": "400",
      "title": "Bad Request"
    }
  ]
}
```
{% /tab %}
{% /tabs %}
{% /tab %}

{% tab label="422" %}
Unprocessable Entity.

{% 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
# Path parameters
export id="CHANGE_ME"

# 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 PATCH "https://api.${DD_SITE}/api/v2/rum/applications/${id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "name": "updated_name_for_my_existing_rum_application",
      "type": "browser"
    },
    "id": "abcd1234-0000-0000-abcd-1234abcd5678",
    "type": "rum_application_update"
  }
}
EOF
```

```bash
# Path parameters
export id="CHANGE_ME"

# 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 PATCH "https://api.${DD_SITE}/api/v2/rum/applications/${id}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "name": "updated_rum_with_product_scales",
      "rum_event_processing_state": "ALL",
      "product_analytics_retention_state": "MAX"
    },
    "id": "abcd1234-0000-0000-abcd-1234abcd5678",
    "type": "rum_application_update"
  }
}
EOF
```
{% /tab %}

{% tab label="Go" %}
```go
// Update a RUM application 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() {
	// there is a valid "rum_application" in the system
	RumApplicationDataID := os.Getenv("RUM_APPLICATION_DATA_ID")

	body := datadogV2.RUMApplicationUpdateRequest{
		Data: datadogV2.RUMApplicationUpdate{
			Attributes: &datadogV2.RUMApplicationUpdateAttributes{
				Name: datadog.PtrString("updated_name_for_my_existing_rum_application"),
				Type: datadog.PtrString("browser"),
			},
			Id:   RumApplicationDataID,
			Type: datadogV2.RUMAPPLICATIONUPDATETYPE_RUM_APPLICATION_UPDATE,
		},
	}
	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.NewRUMApi(apiClient)
	resp, r, err := api.UpdateRUMApplication(ctx, RumApplicationDataID, body)

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

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

```go
// Update a RUM application with Product Scales 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() {
	// there is a valid "rum_application" in the system
	RumApplicationDataID := os.Getenv("RUM_APPLICATION_DATA_ID")

	body := datadogV2.RUMApplicationUpdateRequest{
		Data: datadogV2.RUMApplicationUpdate{
			Attributes: &datadogV2.RUMApplicationUpdateAttributes{
				Name:                           datadog.PtrString("updated_rum_with_product_scales"),
				RumEventProcessingState:        datadogV2.RUMEVENTPROCESSINGSTATE_ALL.Ptr(),
				ProductAnalyticsRetentionState: datadogV2.RUMPRODUCTANALYTICSRETENTIONSTATE_MAX.Ptr(),
			},
			Id:   RumApplicationDataID,
			Type: datadogV2.RUMAPPLICATIONUPDATETYPE_RUM_APPLICATION_UPDATE,
		},
	}
	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.NewRUMApi(apiClient)
	resp, r, err := api.UpdateRUMApplication(ctx, RumApplicationDataID, body)

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

	responseContent, _ := json.MarshalIndent(resp, "", "  ")
	fmt.Fprintf(os.Stdout, "Response from `RUMApi.UpdateRUMApplication`:\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
// Update a RUM application returns "OK" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.RumApi;
import com.datadog.api.client.v2.model.RUMApplicationResponse;
import com.datadog.api.client.v2.model.RUMApplicationUpdate;
import com.datadog.api.client.v2.model.RUMApplicationUpdateAttributes;
import com.datadog.api.client.v2.model.RUMApplicationUpdateRequest;
import com.datadog.api.client.v2.model.RUMApplicationUpdateType;

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

    // there is a valid "rum_application" in the system
    String RUM_APPLICATION_DATA_ID = System.getenv("RUM_APPLICATION_DATA_ID");

    RUMApplicationUpdateRequest body =
        new RUMApplicationUpdateRequest()
            .data(
                new RUMApplicationUpdate()
                    .attributes(
                        new RUMApplicationUpdateAttributes()
                            .name("updated_name_for_my_existing_rum_application")
                            .type("browser"))
                    .id(RUM_APPLICATION_DATA_ID)
                    .type(RUMApplicationUpdateType.RUM_APPLICATION_UPDATE));

    try {
      RUMApplicationResponse result =
          apiInstance.updateRUMApplication(RUM_APPLICATION_DATA_ID, body);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling RumApi#updateRUMApplication");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}
```

```java
// Update a RUM application with Product Scales returns "OK" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.RumApi;
import com.datadog.api.client.v2.model.RUMApplicationResponse;
import com.datadog.api.client.v2.model.RUMApplicationUpdate;
import com.datadog.api.client.v2.model.RUMApplicationUpdateAttributes;
import com.datadog.api.client.v2.model.RUMApplicationUpdateRequest;
import com.datadog.api.client.v2.model.RUMApplicationUpdateType;
import com.datadog.api.client.v2.model.RUMEventProcessingState;
import com.datadog.api.client.v2.model.RUMProductAnalyticsRetentionState;

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

    // there is a valid "rum_application" in the system
    String RUM_APPLICATION_DATA_ID = System.getenv("RUM_APPLICATION_DATA_ID");

    RUMApplicationUpdateRequest body =
        new RUMApplicationUpdateRequest()
            .data(
                new RUMApplicationUpdate()
                    .attributes(
                        new RUMApplicationUpdateAttributes()
                            .name("updated_rum_with_product_scales")
                            .rumEventProcessingState(RUMEventProcessingState.ALL)
                            .productAnalyticsRetentionState(RUMProductAnalyticsRetentionState.MAX))
                    .id(RUM_APPLICATION_DATA_ID)
                    .type(RUMApplicationUpdateType.RUM_APPLICATION_UPDATE));

    try {
      RUMApplicationResponse result =
          apiInstance.updateRUMApplication(RUM_APPLICATION_DATA_ID, body);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling RumApi#updateRUMApplication");
      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
"""
Update a RUM application returns "OK" response
"""

from os import environ
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.rum_api import RUMApi
from datadog_api_client.v2.model.rum_application_update import RUMApplicationUpdate
from datadog_api_client.v2.model.rum_application_update_attributes import RUMApplicationUpdateAttributes
from datadog_api_client.v2.model.rum_application_update_request import RUMApplicationUpdateRequest
from datadog_api_client.v2.model.rum_application_update_type import RUMApplicationUpdateType

# there is a valid "rum_application" in the system
RUM_APPLICATION_DATA_ID = environ["RUM_APPLICATION_DATA_ID"]

body = RUMApplicationUpdateRequest(
    data=RUMApplicationUpdate(
        attributes=RUMApplicationUpdateAttributes(
            name="updated_name_for_my_existing_rum_application",
            type="browser",
        ),
        id=RUM_APPLICATION_DATA_ID,
        type=RUMApplicationUpdateType.RUM_APPLICATION_UPDATE,
    ),
)

configuration = Configuration()
configuration.access_token = environ["DD_BEARER_TOKEN"]
with ApiClient(configuration) as api_client:
    api_instance = RUMApi(api_client)
    response = api_instance.update_rum_application(id=RUM_APPLICATION_DATA_ID, body=body)

    print(response)
```

```python
"""
Update a RUM application with Product Scales returns "OK" response
"""

from os import environ
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.rum_api import RUMApi
from datadog_api_client.v2.model.rum_application_update import RUMApplicationUpdate
from datadog_api_client.v2.model.rum_application_update_attributes import RUMApplicationUpdateAttributes
from datadog_api_client.v2.model.rum_application_update_request import RUMApplicationUpdateRequest
from datadog_api_client.v2.model.rum_application_update_type import RUMApplicationUpdateType
from datadog_api_client.v2.model.rum_event_processing_state import RUMEventProcessingState
from datadog_api_client.v2.model.rum_product_analytics_retention_state import RUMProductAnalyticsRetentionState

# there is a valid "rum_application" in the system
RUM_APPLICATION_DATA_ID = environ["RUM_APPLICATION_DATA_ID"]

body = RUMApplicationUpdateRequest(
    data=RUMApplicationUpdate(
        attributes=RUMApplicationUpdateAttributes(
            name="updated_rum_with_product_scales",
            rum_event_processing_state=RUMEventProcessingState.ALL,
            product_analytics_retention_state=RUMProductAnalyticsRetentionState.MAX,
        ),
        id=RUM_APPLICATION_DATA_ID,
        type=RUMApplicationUpdateType.RUM_APPLICATION_UPDATE,
    ),
)

configuration = Configuration()
configuration.access_token = environ["DD_BEARER_TOKEN"]
with ApiClient(configuration) as api_client:
    api_instance = RUMApi(api_client)
    response = api_instance.update_rum_application(id=RUM_APPLICATION_DATA_ID, body=body)

    print(response)
```

#### Instructions

First [install the library and its dependencies](https://docs.datadoghq.com/api/latest.md?code-lang=python) and then save the example to `example.py` and run following commands:

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

{% tab label="Ruby" %}
```ruby
# Update a RUM application returns "OK" response

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

# there is a valid "rum_application" in the system
RUM_APPLICATION_DATA_ID = ENV["RUM_APPLICATION_DATA_ID"]

body = DatadogAPIClient::V2::RUMApplicationUpdateRequest.new({
  data: DatadogAPIClient::V2::RUMApplicationUpdate.new({
    attributes: DatadogAPIClient::V2::RUMApplicationUpdateAttributes.new({
      name: "updated_name_for_my_existing_rum_application",
      type: "browser",
    }),
    id: RUM_APPLICATION_DATA_ID,
    type: DatadogAPIClient::V2::RUMApplicationUpdateType::RUM_APPLICATION_UPDATE,
  }),
})
p api_instance.update_rum_application(RUM_APPLICATION_DATA_ID, body)
```

```ruby
# Update a RUM application with Product Scales returns "OK" response

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

# there is a valid "rum_application" in the system
RUM_APPLICATION_DATA_ID = ENV["RUM_APPLICATION_DATA_ID"]

body = DatadogAPIClient::V2::RUMApplicationUpdateRequest.new({
  data: DatadogAPIClient::V2::RUMApplicationUpdate.new({
    attributes: DatadogAPIClient::V2::RUMApplicationUpdateAttributes.new({
      name: "updated_rum_with_product_scales",
      rum_event_processing_state: DatadogAPIClient::V2::RUMEventProcessingState::ALL,
      product_analytics_retention_state: DatadogAPIClient::V2::RUMProductAnalyticsRetentionState::MAX,
    }),
    id: RUM_APPLICATION_DATA_ID,
    type: DatadogAPIClient::V2::RUMApplicationUpdateType::RUM_APPLICATION_UPDATE,
  }),
})
p api_instance.update_rum_application(RUM_APPLICATION_DATA_ID, body)
```

#### Instructions

First [install the library and its dependencies](https://docs.datadoghq.com/api/latest.md?code-lang=ruby) and then save the example to `example.rb` and run following commands:

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

{% tab label="Rust" %}
```rust
// Update a RUM application returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_rum::RUMAPI;
use datadog_api_client::datadogV2::model::RUMApplicationUpdate;
use datadog_api_client::datadogV2::model::RUMApplicationUpdateAttributes;
use datadog_api_client::datadogV2::model::RUMApplicationUpdateRequest;
use datadog_api_client::datadogV2::model::RUMApplicationUpdateType;

#[tokio::main]
async fn main() {
    // there is a valid "rum_application" in the system
    let rum_application_data_id = std::env::var("RUM_APPLICATION_DATA_ID").unwrap();
    let body = RUMApplicationUpdateRequest::new(
        RUMApplicationUpdate::new(
            rum_application_data_id.clone(),
            RUMApplicationUpdateType::RUM_APPLICATION_UPDATE,
        )
        .attributes(
            RUMApplicationUpdateAttributes::new()
                .name("updated_name_for_my_existing_rum_application".to_string())
                .type_("browser".to_string()),
        ),
    );
    let configuration = datadog::Configuration::new();
    let api = RUMAPI::with_config(configuration);
    let resp = api
        .update_rum_application(rum_application_data_id.clone(), body)
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}
```

```rust
// Update a RUM application with Product Scales returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_rum::RUMAPI;
use datadog_api_client::datadogV2::model::RUMApplicationUpdate;
use datadog_api_client::datadogV2::model::RUMApplicationUpdateAttributes;
use datadog_api_client::datadogV2::model::RUMApplicationUpdateRequest;
use datadog_api_client::datadogV2::model::RUMApplicationUpdateType;
use datadog_api_client::datadogV2::model::RUMEventProcessingState;
use datadog_api_client::datadogV2::model::RUMProductAnalyticsRetentionState;

#[tokio::main]
async fn main() {
    // there is a valid "rum_application" in the system
    let rum_application_data_id = std::env::var("RUM_APPLICATION_DATA_ID").unwrap();
    let body = RUMApplicationUpdateRequest::new(
        RUMApplicationUpdate::new(
            rum_application_data_id.clone(),
            RUMApplicationUpdateType::RUM_APPLICATION_UPDATE,
        )
        .attributes(
            RUMApplicationUpdateAttributes::new()
                .name("updated_rum_with_product_scales".to_string())
                .product_analytics_retention_state(RUMProductAnalyticsRetentionState::MAX)
                .rum_event_processing_state(RUMEventProcessingState::ALL),
        ),
    );
    let configuration = datadog::Configuration::new();
    let api = RUMAPI::with_config(configuration);
    let resp = api
        .update_rum_application(rum_application_data_id.clone(), body)
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}
```

#### Instructions

First [install the library and its dependencies](https://docs.datadoghq.com/api/latest.md?code-lang=rust) and then save the example to `src/main.rs` and run following commands:

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

{% tab label="TypeScript" %}
```typescript
/**
 * Update a RUM application 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.RUMApi(configuration);

// there is a valid "rum_application" in the system
const RUM_APPLICATION_DATA_ID = process.env.RUM_APPLICATION_DATA_ID as string;

const params: v2.RUMApiUpdateRUMApplicationRequest = {
  body: {
    data: {
      attributes: {
        name: "updated_name_for_my_existing_rum_application",
        type: "browser",
      },
      id: RUM_APPLICATION_DATA_ID,
      type: "rum_application_update",
    },
  },
  id: RUM_APPLICATION_DATA_ID,
};

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

```typescript
/**
 * Update a RUM application with Product Scales 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.RUMApi(configuration);

// there is a valid "rum_application" in the system
const RUM_APPLICATION_DATA_ID = process.env.RUM_APPLICATION_DATA_ID as string;

const params: v2.RUMApiUpdateRUMApplicationRequest = {
  body: {
    data: {
      attributes: {
        name: "updated_rum_with_product_scales",
        rumEventProcessingState: "ALL",
        productAnalyticsRetentionState: "MAX",
      },
      id: RUM_APPLICATION_DATA_ID,
      type: "rum_application_update",
    },
  },
  id: RUM_APPLICATION_DATA_ID,
};

apiInstance
  .updateRUMApplication(params)
  .then((data: v2.RUMApplicationResponse) => {
    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 %}
