---
title: Create a feature flag
description: Creates a new feature flag with variants.
breadcrumbs: Docs > API > Create a feature flag
---

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

# Create a feature flag

## v2 (latest)

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

### Overview

Creates a new feature flag with variants.

This endpoint requires all of the following permissions:

- `feature_flag_config_write`
- `feature_flag_environment_config_read`

OAuth apps require the `feature_flag_config_write`, `feature_flag_environment_config_read` authorization [scope](https://docs.datadoghq.com/api/latest/scopes.md#feature-flags) to access this endpoint.

### Request

#### Body Data (required)

{% tabs %}
{% tab label="Model" %}
| Parent field | Field                   | Type     | Description                                                                                                               |
| ------------ | ----------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------- |
|              | data [*required*]       | object   | Data for creating a new feature flag.                                                                                     |
| data         | attributes [*required*] | object   | Attributes for creating a new feature flag.                                                                               |
| attributes   | default_variant_key     | string   | The key of the default variant.                                                                                           |
| attributes   | description             | string   | The description of the feature flag.                                                                                      |
| attributes   | distribution_channel    | enum     | The distribution channel for the feature flag. Allowed enum values: `ALL`, `CLIENT`, `SERVER`.                            |
| attributes   | json_schema             | string   | JSON schema for validation when value_type is JSON.                                                                       |
| attributes   | key [*required*]        | string   | The unique key of the feature flag.                                                                                       |
| attributes   | name [*required*]       | string   | The name of the feature flag.                                                                                             |
| attributes   | require_approval        | boolean  | Indicates whether this feature flag requires approval for changes.                                                        |
| attributes   | staleness_status        | enum     | The staleness status for the feature flag at creation. Allowed enum values: `ACTIVE`, `PERMANENT`.                        |
| attributes   | tags                    | [string] | Tags associated with the feature flag.                                                                                    |
| attributes   | value_type [*required*] | enum     | The type of values for the feature flag variants. Allowed enum values: `BOOLEAN`, `INTEGER`, `NUMERIC`, `STRING`, `JSON`. |
| attributes   | variants [*required*]   | [object] | The variants of the feature flag.                                                                                         |
| variants     | key [*required*]        | string   | The unique key of the variant.                                                                                            |
| variants     | name [*required*]       | string   | The name of the variant.                                                                                                  |
| variants     | value [*required*]      | string   | The value of the variant as a string.                                                                                     |
| data         | type [*required*]       | enum     | The resource type. Allowed enum values: `feature-flags`.                                                                  |
{% /tab %}

{% tab label="Example" %}
```json
{
  "data": {
    "type": "feature-flags",
    "attributes": {
      "default_variant_key": "variant-Example-Feature-Flag-1",
      "distribution_channel": "SERVER",
      "key": "test-feature-flag-Example-Feature-Flag",
      "name": "Test Feature Flag Example-Feature-Flag",
      "require_approval": false,
      "staleness_status": "PERMANENT",
      "tags": [
        "env:api-client-test"
      ],
      "value_type": "BOOLEAN",
      "variants": [
        {
          "key": "variant-Example-Feature-Flag-1",
          "name": "Variant Example-Feature-Flag A",
          "value": "true"
        },
        {
          "key": "variant-Example-Feature-Flag-2",
          "name": "Variant Example-Feature-Flag B",
          "value": "false"
        }
      ]
    }
  }
}
```
{% /tab %}
{% /tabs %}

### Response

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

{% tabs %}
{% tab label="Model" %}
Response containing a feature flag.

| Parent field              | Field                         | Type      | Description                                                                                                                                                                                                                                                                                                                        |
| ------------------------- | ----------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|                           | data [*required*]             | object    | A feature flag resource.                                                                                                                                                                                                                                                                                                           |
| data                      | attributes [*required*]       | object    | Attributes of a feature flag.                                                                                                                                                                                                                                                                                                      |
| attributes                | archived_at                   | date-time | The timestamp when the feature flag was archived.                                                                                                                                                                                                                                                                                  |
| attributes                | created_at                    | date-time | The timestamp when the feature flag was created.                                                                                                                                                                                                                                                                                   |
| attributes                | created_by                    | uuid      | The ID of the user who created the feature flag.                                                                                                                                                                                                                                                                                   |
| attributes                | description [*required*]      | string    | The description of the feature flag.                                                                                                                                                                                                                                                                                               |
| attributes                | distribution_channel          | string    | Distribution channel for the feature flag.                                                                                                                                                                                                                                                                                         |
| attributes                | feature_flag_environments     | [object]  | Environment-specific settings for the feature flag.                                                                                                                                                                                                                                                                                |
| feature_flag_environments | allocations                   | object    | Allocation metadata for this environment.                                                                                                                                                                                                                                                                                          |
| feature_flag_environments | default_allocation_key        | string    | A system-generated allocation key, in the format `allocation-default-<hash>`, that SDKs report in flag evaluation results and exposure events when a subject receives the environment's default variant because no targeting rule matched. It has no corresponding allocation ID and cannot be used with the allocation endpoints. |
| feature_flag_environments | default_variant_id            | string    | The ID of the default variant for this environment.                                                                                                                                                                                                                                                                                |
| feature_flag_environments | environment_id [*required*]   | uuid      | The ID of the environment.                                                                                                                                                                                                                                                                                                         |
| feature_flag_environments | environment_name              | string    | The name of the environment.                                                                                                                                                                                                                                                                                                       |
| feature_flag_environments | environment_queries           | [string]  | Queries that target this environment.                                                                                                                                                                                                                                                                                              |
| feature_flag_environments | is_production                 | boolean   | Indicates whether the environment is production.                                                                                                                                                                                                                                                                                   |
| feature_flag_environments | observe_full_evaluation_data  | boolean   | Indicates whether feature flag evaluation events include original targeting identifiers and full evaluation context.                                                                                                                                                                                                               |
| feature_flag_environments | override_allocation_key       | string    | A system-generated allocation key, in the format `allocation-override-<hash>`, that SDKs report in flag evaluation results and exposure events when the environment's override variant is served. It has no corresponding allocation ID and cannot be used with the allocation endpoints.                                          |
| feature_flag_environments | override_variant_id           | string    | The ID of the override variant for this environment.                                                                                                                                                                                                                                                                               |
| feature_flag_environments | pending_suggestion_id         | string    | Pending suggestion identifier, if approval is required.                                                                                                                                                                                                                                                                            |
| feature_flag_environments | require_feature_flag_approval | boolean   | Indicates whether feature flag changes require approval in this environment.                                                                                                                                                                                                                                                       |
| feature_flag_environments | status [*required*]           | enum      | The status of a feature flag in an environment. Allowed enum values: `ENABLED`, `DISABLED`.                                                                                                                                                                                                                                        |
| attributes                | is_favorite                   | boolean   | Indicates whether the current user has marked the feature flag as a favorite.                                                                                                                                                                                                                                                      |
| attributes                | json_schema                   | string    | JSON schema for validation when value_type is JSON.                                                                                                                                                                                                                                                                                |
| attributes                | key [*required*]              | string    | The unique key of the feature flag.                                                                                                                                                                                                                                                                                                |
| attributes                | last_updated_by               | uuid      | The ID of the user who last updated the feature flag.                                                                                                                                                                                                                                                                              |
| attributes                | name [*required*]             | string    | The name of the feature flag.                                                                                                                                                                                                                                                                                                      |
| attributes                | require_approval              | boolean   | Indicates whether this feature flag requires approval for changes.                                                                                                                                                                                                                                                                 |
| attributes                | staleness_details             | object    | The feature flag's current staleness state and suggested actions.                                                                                                                                                                                                                                                                  |
| staleness_details         | code_references               | [object]  | Repositories and files where the flag is referenced in source code.                                                                                                                                                                                                                                                                |
| code_references           | files                         | [string]  | Paths of files that reference the feature flag in this repository.                                                                                                                                                                                                                                                                 |
| code_references           | repo_url                      | string    | The URL of the source code repository, when available.                                                                                                                                                                                                                                                                             |
| code_references           | scm_repository_id             | string    | The identifier of the source code repository.                                                                                                                                                                                                                                                                                      |
| staleness_details         | dismissed_by                  | string    | The ID of the user who dismissed the staleness recommendation.                                                                                                                                                                                                                                                                     |
| staleness_details         | id                            | string    | The ID of the feature flag whose staleness state is returned.                                                                                                                                                                                                                                                                      |
| staleness_details         | recommended_actions           | [object]  | Suggested actions for the flag. The first action is the primary recommendation.                                                                                                                                                                                                                                                    |
| recommended_actions       | action                        | string    | The action to consider. Values include `remove_from_code`, `archive_flag`, `mark_as_permanent`, `snooze`, and `check_sdk_config`.                                                                                                                                                                                                  |
| recommended_actions       | description                   | string    | An explanation of the suggested action.                                                                                                                                                                                                                                                                                            |
| staleness_details         | skip_state_check_until        | date-time | Time until which staleness checks are paused for the flag.                                                                                                                                                                                                                                                                         |
| staleness_details         | stale_reason                  | string    | Why the flag is stale or has a manually selected state. Values include `FULLY_ROLLED_OUT`, `NO_EVALUATIONS`, `NO_ACTIVITY`, and `USER_SET`.                                                                                                                                                                                        |
| staleness_details         | staleness_status              | string    | The current state, such as `ACTIVE`, `STALE`, or `PERMANENT`.                                                                                                                                                                                                                                                                      |
| attributes                | staleness_status              | string    | Indicates the whether a feature flag is stale or not.                                                                                                                                                                                                                                                                              |
| attributes                | staleness_status_override     | enum      | An explicit staleness status override. Omitted when no override is set. Allowed enum values: `STALE`, `PERMANENT`.                                                                                                                                                                                                                 |
| attributes                | tags                          | [string]  | Tags associated with the feature flag.                                                                                                                                                                                                                                                                                             |
| attributes                | updated_at                    | date-time | The timestamp when the feature flag was last updated.                                                                                                                                                                                                                                                                              |
| attributes                | value_type [*required*]       | enum      | The type of values for the feature flag variants. Allowed enum values: `BOOLEAN`, `INTEGER`, `NUMERIC`, `STRING`, `JSON`.                                                                                                                                                                                                          |
| attributes                | variants [*required*]         | [object]  | The variants of the feature flag.                                                                                                                                                                                                                                                                                                  |
| variants                  | created_at                    | date-time | The timestamp when the variant was created.                                                                                                                                                                                                                                                                                        |
| variants                  | id [*required*]               | uuid      | The unique identifier of the variant.                                                                                                                                                                                                                                                                                              |
| variants                  | key [*required*]              | string    | The unique key of the variant.                                                                                                                                                                                                                                                                                                     |
| variants                  | name [*required*]             | string    | The name of the variant.                                                                                                                                                                                                                                                                                                           |
| variants                  | updated_at                    | date-time | The timestamp when the variant was last updated.                                                                                                                                                                                                                                                                                   |
| variants                  | value [*required*]            | string    | The value of the variant as a string.                                                                                                                                                                                                                                                                                              |
| data                      | id [*required*]               | uuid      | The unique identifier of the feature flag.                                                                                                                                                                                                                                                                                         |
| data                      | type [*required*]             | enum      | The resource type. Allowed enum values: `feature-flags`.                                                                                                                                                                                                                                                                           |
{% /tab %}

{% tab label="Example" %}
```json
{
  "data": {
    "attributes": {
      "archived_at": "2023-01-01T00:00:00Z",
      "created_at": "2023-01-01T00:00:00Z",
      "created_by": "550e8400-e29b-41d4-a716-446655440010",
      "description": "This is an example feature flag for demonstration",
      "distribution_channel": "ALL",
      "feature_flag_environments": [
        {
          "allocations": {},
          "default_allocation_key": "allocation-default-123abc",
          "default_variant_id": "550e8400-e29b-41d4-a716-446655440002",
          "environment_id": "550e8400-e29b-41d4-a716-446655440001",
          "environment_name": "env-search-term",
          "environment_queries": [
            "test-feature-flag",
            "env-search-term"
          ],
          "is_production": false,
          "observe_full_evaluation_data": false,
          "override_allocation_key": "allocation-override-123abc",
          "override_variant_id": "550e8400-e29b-41d4-a716-446655440003",
          "pending_suggestion_id": "550e8400-e29b-41d4-a716-446655440099",
          "require_feature_flag_approval": false,
          "status": "ENABLED"
        }
      ],
      "is_favorite": false,
      "json_schema": "{\"type\": \"object\", \"properties\": {\"enabled\": {\"type\": \"boolean\"}}}",
      "key": "feature-flag-abc123",
      "last_updated_by": "550e8400-e29b-41d4-a716-446655440010",
      "name": "Feature Flag ABC123",
      "require_approval": false,
      "staleness_details": {
        "code_references": [
          {
            "files": [
              "src/feature_flags.ts"
            ],
            "repo_url": "https://github.com/example/application",
            "scm_repository_id": "repository-1"
          }
        ],
        "dismissed_by": "550e8400-e29b-41d4-a716-446655440010",
        "id": "550e8400-e29b-41d4-a716-446655440000",
        "recommended_actions": [
          {
            "action": "archive_flag",
            "description": "Archive the feature flag."
          }
        ],
        "skip_state_check_until": "2026-09-30T12:00:00Z",
        "stale_reason": "NO_EVALUATIONS",
        "staleness_status": "ACTIVE"
      },
      "staleness_status": "ACTIVE",
      "staleness_status_override": "PERMANENT",
      "tags": [
        []
      ],
      "updated_at": "2023-01-01T00:00:00Z",
      "value_type": "BOOLEAN",
      "variants": [
        {
          "created_at": "2023-01-01T00:00:00Z",
          "id": "550e8400-e29b-41d4-a716-446655440002",
          "key": "variant-abc123",
          "name": "Variant ABC123",
          "updated_at": "2023-01-01T00:00:00Z",
          "value": "true"
        }
      ]
    },
    "id": "550e8400-e29b-41d4-a716-446655440000",
    "type": "feature-flags"
  }
}
```
{% /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" %}
Forbidden

{% 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/feature-flags" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "type": "feature-flags",
    "attributes": {
      "default_variant_key": "variant-Example-Feature-Flag-1",
      "distribution_channel": "SERVER",
      "key": "test-feature-flag-Example-Feature-Flag",
      "name": "Test Feature Flag Example-Feature-Flag",
      "require_approval": false,
      "staleness_status": "PERMANENT",
      "tags": [
        "env:api-client-test"
      ],
      "value_type": "BOOLEAN",
      "variants": [
        {
          "key": "variant-Example-Feature-Flag-1",
          "name": "Variant Example-Feature-Flag A",
          "value": "true"
        },
        {
          "key": "variant-Example-Feature-Flag-2",
          "name": "Variant Example-Feature-Flag B",
          "value": "false"
        }
      ]
    }
  }
}
EOF
```
{% /tab %}

{% tab label="Go" %}
```go
// Create a feature flag 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.CreateFeatureFlagRequest{
		Data: datadogV2.CreateFeatureFlagData{
			Type: datadogV2.CREATEFEATUREFLAGDATATYPE_FEATURE_FLAGS,
			Attributes: datadogV2.CreateFeatureFlagAttributes{
				DefaultVariantKey:   *datadog.NewNullableString(datadog.PtrString("variant-Example-Feature-Flag-1")),
				DistributionChannel: datadogV2.FEATUREFLAGDISTRIBUTIONCHANNEL_SERVER.Ptr(),
				Key:                 "test-feature-flag-Example-Feature-Flag",
				Name:                "Test Feature Flag Example-Feature-Flag",
				RequireApproval:     datadog.PtrBool(false),
				StalenessStatus:     datadogV2.CREATEFEATUREFLAGSTALENESSSTATUS_PERMANENT.Ptr(),
				Tags: []string{
					"env:api-client-test",
				},
				ValueType: datadogV2.VALUETYPE_BOOLEAN,
				Variants: []datadogV2.CreateVariant{
					{
						Key:   "variant-Example-Feature-Flag-1",
						Name:  "Variant Example-Feature-Flag A",
						Value: "true",
					},
					{
						Key:   "variant-Example-Feature-Flag-2",
						Name:  "Variant Example-Feature-Flag B",
						Value: "false",
					},
				},
			},
		},
	}
	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.NewFeatureFlagsApi(apiClient)
	resp, r, err := api.CreateFeatureFlag(ctx, body)

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

	responseContent, _ := json.MarshalIndent(resp, "", "  ")
	fmt.Fprintf(os.Stdout, "Response from `FeatureFlagsApi.CreateFeatureFlag`:\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
// Create a feature flag returns "Created" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.FeatureFlagsApi;
import com.datadog.api.client.v2.model.CreateFeatureFlagAttributes;
import com.datadog.api.client.v2.model.CreateFeatureFlagData;
import com.datadog.api.client.v2.model.CreateFeatureFlagDataType;
import com.datadog.api.client.v2.model.CreateFeatureFlagRequest;
import com.datadog.api.client.v2.model.CreateFeatureFlagStalenessStatus;
import com.datadog.api.client.v2.model.CreateVariant;
import com.datadog.api.client.v2.model.FeatureFlagDistributionChannel;
import com.datadog.api.client.v2.model.FeatureFlagResponse;
import com.datadog.api.client.v2.model.ValueType;
import java.util.Arrays;
import java.util.Collections;

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

    CreateFeatureFlagRequest body =
        new CreateFeatureFlagRequest()
            .data(
                new CreateFeatureFlagData()
                    .type(CreateFeatureFlagDataType.FEATURE_FLAGS)
                    .attributes(
                        new CreateFeatureFlagAttributes()
                            .defaultVariantKey("variant-Example-Feature-Flag-1")
                            .distributionChannel(FeatureFlagDistributionChannel.SERVER)
                            .key("test-feature-flag-Example-Feature-Flag")
                            .name("Test Feature Flag Example-Feature-Flag")
                            .requireApproval(false)
                            .stalenessStatus(CreateFeatureFlagStalenessStatus.PERMANENT)
                            .tags(Collections.singletonList("env:api-client-test"))
                            .valueType(ValueType.BOOLEAN)
                            .variants(
                                Arrays.asList(
                                    new CreateVariant()
                                        .key("variant-Example-Feature-Flag-1")
                                        .name("Variant Example-Feature-Flag A")
                                        .value("true"),
                                    new CreateVariant()
                                        .key("variant-Example-Feature-Flag-2")
                                        .name("Variant Example-Feature-Flag B")
                                        .value("false")))));

    try {
      FeatureFlagResponse result = apiInstance.createFeatureFlag(body);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling FeatureFlagsApi#createFeatureFlag");
      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
"""
Create a feature flag returns "Created" response
"""

from os import environ
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.feature_flags_api import FeatureFlagsApi
from datadog_api_client.v2.model.create_feature_flag_attributes import CreateFeatureFlagAttributes
from datadog_api_client.v2.model.create_feature_flag_data import CreateFeatureFlagData
from datadog_api_client.v2.model.create_feature_flag_data_type import CreateFeatureFlagDataType
from datadog_api_client.v2.model.create_feature_flag_request import CreateFeatureFlagRequest
from datadog_api_client.v2.model.create_feature_flag_staleness_status import CreateFeatureFlagStalenessStatus
from datadog_api_client.v2.model.create_variant import CreateVariant
from datadog_api_client.v2.model.feature_flag_distribution_channel import FeatureFlagDistributionChannel
from datadog_api_client.v2.model.value_type import ValueType

body = CreateFeatureFlagRequest(
    data=CreateFeatureFlagData(
        type=CreateFeatureFlagDataType.FEATURE_FLAGS,
        attributes=CreateFeatureFlagAttributes(
            default_variant_key="variant-Example-Feature-Flag-1",
            distribution_channel=FeatureFlagDistributionChannel.SERVER,
            key="test-feature-flag-Example-Feature-Flag",
            name="Test Feature Flag Example-Feature-Flag",
            require_approval=False,
            staleness_status=CreateFeatureFlagStalenessStatus.PERMANENT,
            tags=[
                "env:api-client-test",
            ],
            value_type=ValueType.BOOLEAN,
            variants=[
                CreateVariant(
                    key="variant-Example-Feature-Flag-1",
                    name="Variant Example-Feature-Flag A",
                    value="true",
                ),
                CreateVariant(
                    key="variant-Example-Feature-Flag-2",
                    name="Variant Example-Feature-Flag B",
                    value="false",
                ),
            ],
        ),
    ),
)

configuration = Configuration()
configuration.access_token = environ["DD_BEARER_TOKEN"]
with ApiClient(configuration) as api_client:
    api_instance = FeatureFlagsApi(api_client)
    response = api_instance.create_feature_flag(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
# Create a feature flag returns "Created" response

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

body = DatadogAPIClient::V2::CreateFeatureFlagRequest.new({
  data: DatadogAPIClient::V2::CreateFeatureFlagData.new({
    type: DatadogAPIClient::V2::CreateFeatureFlagDataType::FEATURE_FLAGS,
    attributes: DatadogAPIClient::V2::CreateFeatureFlagAttributes.new({
      default_variant_key: "variant-Example-Feature-Flag-1",
      distribution_channel: DatadogAPIClient::V2::FeatureFlagDistributionChannel::SERVER,
      key: "test-feature-flag-Example-Feature-Flag",
      name: "Test Feature Flag Example-Feature-Flag",
      require_approval: false,
      staleness_status: DatadogAPIClient::V2::CreateFeatureFlagStalenessStatus::PERMANENT,
      tags: [
        "env:api-client-test",
      ],
      value_type: DatadogAPIClient::V2::ValueType::BOOLEAN,
      variants: [
        DatadogAPIClient::V2::CreateVariant.new({
          key: "variant-Example-Feature-Flag-1",
          name: "Variant Example-Feature-Flag A",
          value: "true",
        }),
        DatadogAPIClient::V2::CreateVariant.new({
          key: "variant-Example-Feature-Flag-2",
          name: "Variant Example-Feature-Flag B",
          value: "false",
        }),
      ],
    }),
  }),
})
p api_instance.create_feature_flag(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
// Create a feature flag returns "Created" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_feature_flags::FeatureFlagsAPI;
use datadog_api_client::datadogV2::model::CreateFeatureFlagAttributes;
use datadog_api_client::datadogV2::model::CreateFeatureFlagData;
use datadog_api_client::datadogV2::model::CreateFeatureFlagDataType;
use datadog_api_client::datadogV2::model::CreateFeatureFlagRequest;
use datadog_api_client::datadogV2::model::CreateFeatureFlagStalenessStatus;
use datadog_api_client::datadogV2::model::CreateVariant;
use datadog_api_client::datadogV2::model::FeatureFlagDistributionChannel;
use datadog_api_client::datadogV2::model::ValueType;

#[tokio::main]
async fn main() {
    let body = CreateFeatureFlagRequest::new(CreateFeatureFlagData::new(
        CreateFeatureFlagAttributes::new(
            "test-feature-flag-Example-Feature-Flag".to_string(),
            "Test Feature Flag Example-Feature-Flag".to_string(),
            ValueType::BOOLEAN,
            vec![
                CreateVariant::new(
                    "variant-Example-Feature-Flag-1".to_string(),
                    "Variant Example-Feature-Flag A".to_string(),
                    "true".to_string(),
                ),
                CreateVariant::new(
                    "variant-Example-Feature-Flag-2".to_string(),
                    "Variant Example-Feature-Flag B".to_string(),
                    "false".to_string(),
                ),
            ],
        )
        .default_variant_key(Some("variant-Example-Feature-Flag-1".to_string()))
        .distribution_channel(FeatureFlagDistributionChannel::SERVER)
        .require_approval(false)
        .staleness_status(CreateFeatureFlagStalenessStatus::PERMANENT)
        .tags(vec!["env:api-client-test".to_string()]),
        CreateFeatureFlagDataType::FEATURE_FLAGS,
    ));
    let configuration = datadog::Configuration::new();
    let api = FeatureFlagsAPI::with_config(configuration);
    let resp = api.create_feature_flag(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="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run
```
{% /tab %}

{% tab label="TypeScript" %}
```typescript
/**
 * Create a feature flag 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.FeatureFlagsApi(configuration);

const params: v2.FeatureFlagsApiCreateFeatureFlagRequest = {
  body: {
    data: {
      type: "feature-flags",
      attributes: {
        defaultVariantKey: "variant-Example-Feature-Flag-1",
        distributionChannel: "SERVER",
        key: "test-feature-flag-Example-Feature-Flag",
        name: "Test Feature Flag Example-Feature-Flag",
        requireApproval: false,
        stalenessStatus: "PERMANENT",
        tags: ["env:api-client-test"],
        valueType: "BOOLEAN",
        variants: [
          {
            key: "variant-Example-Feature-Flag-1",
            name: "Variant Example-Feature-Flag A",
            value: "true",
          },
          {
            key: "variant-Example-Feature-Flag-2",
            name: "Variant Example-Feature-Flag B",
            value: "false",
          },
        ],
      },
    },
  },
};

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