---
title: Modifier l'ordre des règles d'allocation personnalisées
description: Réorganiser les règles d'allocation personnalisées - Modifier l'ordre d'exécution des règles d'allocation personnalisées.
breadcrumbs: Documentation > API > Modifier l'ordre des règles d'allocation personnalisées
---

> For the complete documentation index, see [llms.txt](https://dnd37xeb23o8n.cloudfront.net/jen.gilbert/astro-base/llms.txt).

# Modifier l'ordre des règles d'allocation personnalisées

## v2 (latest)

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

### Overview

Réorganiser les règles d'allocation personnalisées - Modifier l'ordre d'exécution des règles d'allocation personnalisées.

**Important** : vous devez fournir la **liste complète** de tous les ID de règles dans l'ordre d'exécution souhaité. L'API réorganisera TOUTES les règles selon la séquence fournie.

Les règles sont exécutées dans l'ordre spécifié, les indices les plus bas (en début de tableau) ayant la priorité la plus élevée.

**Exemple** : si vous avez des règles avec les ID [123, 456, 789] et souhaitez modifier l'ordre de 123→456→789 à 456→123→789, envoyez : [{"id": "456"}, {"id": "123"}, {"id": "789"}]

OAuth apps require the `cloud_cost_management_write` authorization [scope](https://dnd37xeb23o8n.cloudfront.net/jen.gilbert/astro-base/fr/api/latest/scopes.md#cloud-cost-management) to access this endpoint.

### Request

#### Body Data (required)

{% tabs %}
{% tab label="Model" %}
| Parent field | Field             | Type     | Description                                                                                     |
| ------------ | ----------------- | -------- | ----------------------------------------------------------------------------------------------- |
|              | data [*required*] | [object] | La définition de l'objet `ReorderRuleResourceArray`.                                            |
| data         | id                | string   | The `ReorderRuleResourceData` `id`.                                                             |
| data         | type [*required*] | enum     | Arbitrary rule resource type. Allowed enum values: `arbitrary_rule`. Default: `arbitrary_rule`. |
{% /tab %}

{% tab label="Example" %}
```json
{
  "data": [
    {
      "id": "string",
      "type": "arbitrary_rule"
    }
  ]
}
```
{% /tab %}
{% /tabs %}

### Response

{% tabs %}
{% tab label="204" %}
Successfully reordered rules
{% /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/cost/arbitrary_rule/reorder" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": [
    {
      "id": "456",
      "type": "arbitrary_rule"
    },
    {
      "id": "123",
      "type": "arbitrary_rule"
    },
    {
      "id": "789",
      "type": "arbitrary_rule"
    }
  ]
}
EOF
```
{% /tab %}

{% tab label="Go" %}
```go
// Reorder custom allocation rules returns "Successfully reordered rules" response

package main

import (
	"context"
	"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.ReorderRuleResourceArray{
		Data: []datadogV2.ReorderRuleResourceData{
			{
				Id:   datadog.PtrString("456"),
				Type: datadogV2.REORDERRULERESOURCEDATATYPE_ARBITRARY_RULE,
			},
			{
				Id:   datadog.PtrString("123"),
				Type: datadogV2.REORDERRULERESOURCEDATATYPE_ARBITRARY_RULE,
			},
			{
				Id:   datadog.PtrString("789"),
				Type: datadogV2.REORDERRULERESOURCEDATATYPE_ARBITRARY_RULE,
			},
		},
	}
	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.NewCloudCostManagementApi(apiClient)
	r, err := api.ReorderCustomAllocationRules(ctx, body)

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

#### 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
// Reorder custom allocation rules returns "Successfully reordered rules" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.CloudCostManagementApi;
import com.datadog.api.client.v2.model.ReorderRuleResourceArray;
import com.datadog.api.client.v2.model.ReorderRuleResourceData;
import com.datadog.api.client.v2.model.ReorderRuleResourceDataType;
import java.util.Arrays;

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

    ReorderRuleResourceArray body =
        new ReorderRuleResourceArray()
            .data(
                Arrays.asList(
                    new ReorderRuleResourceData()
                        .id("456")
                        .type(ReorderRuleResourceDataType.ARBITRARY_RULE),
                    new ReorderRuleResourceData()
                        .id("123")
                        .type(ReorderRuleResourceDataType.ARBITRARY_RULE),
                    new ReorderRuleResourceData()
                        .id("789")
                        .type(ReorderRuleResourceDataType.ARBITRARY_RULE)));

    try {
      apiInstance.reorderCustomAllocationRules(body);
    } catch (ApiException e) {
      System.err.println(
          "Exception when calling CloudCostManagementApi#reorderCustomAllocationRules");
      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
"""
Reorder custom allocation rules returns "Successfully reordered rules" response
"""

from os import environ
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.cloud_cost_management_api import CloudCostManagementApi
from datadog_api_client.v2.model.reorder_rule_resource_array import ReorderRuleResourceArray
from datadog_api_client.v2.model.reorder_rule_resource_data import ReorderRuleResourceData
from datadog_api_client.v2.model.reorder_rule_resource_data_type import ReorderRuleResourceDataType

body = ReorderRuleResourceArray(
    data=[
        ReorderRuleResourceData(
            id="456",
            type=ReorderRuleResourceDataType.ARBITRARY_RULE,
        ),
        ReorderRuleResourceData(
            id="123",
            type=ReorderRuleResourceDataType.ARBITRARY_RULE,
        ),
        ReorderRuleResourceData(
            id="789",
            type=ReorderRuleResourceDataType.ARBITRARY_RULE,
        ),
    ],
)

configuration = Configuration()
configuration.access_token = environ["DD_BEARER_TOKEN"]
with ApiClient(configuration) as api_client:
    api_instance = CloudCostManagementApi(api_client)
    api_instance.reorder_custom_allocation_rules(body=body)
```

#### 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
# Reorder custom allocation rules returns "Successfully reordered rules" response

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

body = DatadogAPIClient::V2::ReorderRuleResourceArray.new({
  data: [
    DatadogAPIClient::V2::ReorderRuleResourceData.new({
      id: "456",
      type: DatadogAPIClient::V2::ReorderRuleResourceDataType::ARBITRARY_RULE,
    }),
    DatadogAPIClient::V2::ReorderRuleResourceData.new({
      id: "123",
      type: DatadogAPIClient::V2::ReorderRuleResourceDataType::ARBITRARY_RULE,
    }),
    DatadogAPIClient::V2::ReorderRuleResourceData.new({
      id: "789",
      type: DatadogAPIClient::V2::ReorderRuleResourceDataType::ARBITRARY_RULE,
    }),
  ],
})
api_instance.reorder_custom_allocation_rules(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
// Reorder custom allocation rules returns "Successfully reordered rules" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_cloud_cost_management::CloudCostManagementAPI;
use datadog_api_client::datadogV2::model::ReorderRuleResourceArray;
use datadog_api_client::datadogV2::model::ReorderRuleResourceData;
use datadog_api_client::datadogV2::model::ReorderRuleResourceDataType;

#[tokio::main]
async fn main() {
    let body = ReorderRuleResourceArray::new(vec![
        ReorderRuleResourceData::new(ReorderRuleResourceDataType::ARBITRARY_RULE)
            .id("456".to_string()),
        ReorderRuleResourceData::new(ReorderRuleResourceDataType::ARBITRARY_RULE)
            .id("123".to_string()),
        ReorderRuleResourceData::new(ReorderRuleResourceDataType::ARBITRARY_RULE)
            .id("789".to_string()),
    ]);
    let configuration = datadog::Configuration::new();
    let api = CloudCostManagementAPI::with_config(configuration);
    let resp = api.reorder_custom_allocation_rules(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="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run
```
{% /tab %}

{% tab label="TypeScript" %}
```typescript
/**
 * Reorder custom allocation rules returns "Successfully reordered rules" 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.CloudCostManagementApi(configuration);

const params: v2.CloudCostManagementApiReorderCustomAllocationRulesRequest = {
  body: {
    data: [
      {
        id: "456",
        type: "arbitrary_rule",
      },
      {
        id: "123",
        type: "arbitrary_rule",
      },
      {
        id: "789",
        type: "arbitrary_rule",
      },
    ],
  },
};

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