> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.getunleash.io/api/patch-environments-feature-variants/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.getunleash.io/_mcp/server.

# Patch a feature's variants in an environment

PATCH https://app.unleash-instance.example.com/api/admin/projects/{projectId}/features/{featureName}/environments/{environment}/variants
Content-Type: application/json

Apply a list of patches to the features environments in the specified environment. The patch objects should conform to the [JSON-patch format (RFC 6902)](https://www.rfc-editor.org/rfc/rfc6902).

Reference: https://docs.getunleash.io/api/patch-environments-feature-variants

## Authentication

- `Authorization` header (required) — API key needed to access this API
- `Authorization` header (bearer token, required) — API key needed to access this API, in Bearer token format

## Request

### Path parameters

- `projectId` (string, required)
- `featureName` (string, required)
- `environment` (string, required)

### Body (application/json)

This endpoint expects a list of patchSchema.

- `list of patchSchema`

## Response

### 200

featureVariantsSchema

- `version` (integer, required) — The version of the feature variants schema.
- `variants` (list of variantSchema, required) — All variants defined for a specific feature flag.

## Errors

### 400 Bad Request Error

The request data does not match what we expect.

- `id` (string, optional) — The ID of the error instance
- `name` (string, optional) — The name of the error kind
- `message` (string, optional) — A description of what went wrong.

### 401 Unauthorized Error

Authorization information is missing or invalid. Provide a valid API token as the `authorization` header, e.g. `authorization:*.*.my-admin-token`.

- `id` (string, optional) — The ID of the error instance
- `name` (string, optional) — The name of the error kind
- `message` (string, optional) — A description of what went wrong.

### 403 Forbidden Error

The provided user credentials are valid, but the user does not have the necessary permissions to perform this operation

- `id` (string, optional) — The ID of the error instance
- `name` (string, optional) — The name of the error kind
- `message` (string, optional) — A description of what went wrong.

### 404 Not Found Error

The requested resource was not found.

- `id` (string, optional) — The ID of the error instance
- `name` (string, optional) — The name of the error kind
- `message` (string, optional) — A description of what went wrong.

## Types

### patchSchema

A [JSON patch](https://www.rfc-editor.org/rfc/rfc6902) operation description

- `path` (string, required) — The path to the property to operate on
- `op` (enum, required) — The kind of operation to perform
  - Allowed values: `add`, `remove`, `replace`, `copy`, `move`, `test`
- `from` (string, optional) — The target to move or copy from, if performing one of those operations
- `value` (any, optional) — The value to add or replace, if performing one of those operations

### variantSchema

A variant allows for further separation of users into segments. See [our excellent documentation](https://docs.getunleash.io/concepts/feature-flag-variants#what-are-variants) for a more detailed description

- `name` (string, required) — The variants name. Is unique for this feature flag
- `weight` (double, required) — The weight is the likelihood of any one user getting this variant. It is a number between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/concepts/feature-flag-variants#variant-weight) for more information
- `weightType` (enum, optional) — Set to fix if this variant must have exactly the weight allocated to it. If the type is variable, the weight will adjust so that the total weight of all variants adds up to 1000
  - Allowed values: `variable`, `fix`
- `stickiness` (string, optional) — [Stickiness](https://docs.getunleash.io/concepts/feature-flag-variants#variant-stickiness) is how Unleash guarantees that the same user gets the same variant every time
- `payload` (VariantSchemaPayload, optional) — Extra data configured for this variant
- `overrides` (list of overrideSchema, optional) — Overrides assigning specific variants to specific users. The weighting system automatically assigns users to specific groups for you, but any overrides in this list will take precedence.

### VariantSchemaPayload

Extra data configured for this variant

- `type` (enum, required) — The type of the value. Commonly used types are string, number, json and csv.
  - Allowed values: `json`, `csv`, `string`, `number`
- `value` (string, required) — The actual value of payload

### overrideSchema

An override for deciding which variant should be assigned to a user based on the context name

- `contextName` (string, required) — The name of the context field used to determine overrides
- `values` (list of string, required) — Which values that should be overriden

## Examples

**Request**

```json
[
  {
    "path": "/type",
    "op": "replace"
  }
]
```

**Response**

```json
{
  "version": 1,
  "variants": [
    {
      "name": "blue_group",
      "weight": 1.1,
      "weightType": "variable",
      "stickiness": "custom.context.field",
      "payload": {
        "type": "json",
        "value": "{\"color\": \"red\"}"
      },
      "overrides": [
        {
          "contextName": "userId",
          "values": [
            "red",
            "blue"
          ]
        }
      ]
    }
  ]
}
```

**SDK Code**

```python
import requests

url = "https://app.unleash-instance.example.com/api/admin/projects/projectId/features/featureName/environments/environment/variants"

payload = [
    {
        "path": "/type",
        "op": "replace"
    }
]
headers = {
    "Authorization": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://app.unleash-instance.example.com/api/admin/projects/projectId/features/featureName/environments/environment/variants';
const options = {
  method: 'PATCH',
  headers: {Authorization: '<apiKey>', 'Content-Type': 'application/json'},
  body: '[{"path":"/type","op":"replace"}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.unleash-instance.example.com/api/admin/projects/projectId/features/featureName/environments/environment/variants"

	payload := strings.NewReader("[\n  {\n    \"path\": \"/type\",\n    \"op\": \"replace\"\n  }\n]")

	req, _ := http.NewRequest("PATCH", url, payload)

	req.Header.Add("Authorization", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://app.unleash-instance.example.com/api/admin/projects/projectId/features/featureName/environments/environment/variants")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["Authorization"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "[\n  {\n    \"path\": \"/type\",\n    \"op\": \"replace\"\n  }\n]"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.patch("https://app.unleash-instance.example.com/api/admin/projects/projectId/features/featureName/environments/environment/variants")
  .header("Authorization", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("[\n  {\n    \"path\": \"/type\",\n    \"op\": \"replace\"\n  }\n]")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PATCH', 'https://app.unleash-instance.example.com/api/admin/projects/projectId/features/featureName/environments/environment/variants', [
  'body' => '[
  {
    "path": "/type",
    "op": "replace"
  }
]',
  'headers' => [
    'Authorization' => '<apiKey>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://app.unleash-instance.example.com/api/admin/projects/projectId/features/featureName/environments/environment/variants");
var request = new RestRequest(Method.PATCH);
request.AddHeader("Authorization", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"path\": \"/type\",\n    \"op\": \"replace\"\n  }\n]", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  [
    "path": "/type",
    "op": "replace"
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.unleash-instance.example.com/api/admin/projects/projectId/features/featureName/environments/environment/variants")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```