# 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

## OpenAPI Specification

```yaml
openapi: 3.1.1
info:
  title: Patch a feature's variants in an environment
  version: endpoint_features.patchEnvironmentsFeatureVariants
paths:
  /api/admin/projects/{projectId}/features/{featureName}/environments/{environment}/variants:
    patch:
      operationId: patch-environments-feature-variants
      summary: Patch a feature's variants in an environment
      description: >-
        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).
      tags:
        - - subpackage_features
      parameters:
        - name: projectId
          in: path
          required: true
          schema:
            type: string
        - name: featureName
          in: path
          required: true
          schema:
            type: string
        - name: environment
          in: path
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: Header authentication of the form `undefined <token>`
          required: true
          schema:
            type: string
      responses:
        '200':
          description: featureVariantsSchema
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/featureVariantsSchema'
        '400':
          description: The request data does not match what we expect.
          content: {}
        '401':
          description: >-
            Authorization information is missing or invalid. Provide a valid API
            token as the `authorization` header, e.g.
            `authorization:*.*.my-admin-token`.
          content: {}
        '403':
          description: >-
            The provided user credentials are valid, but the user does not have
            the necessary permissions to perform this operation
          content: {}
        '404':
          description: The requested resource was not found.
          content: {}
      requestBody:
        description: patchesSchema
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/patchesSchema'
components:
  schemas:
    PatchSchemaOp:
      type: string
      enum:
        - value: add
        - value: remove
        - value: replace
        - value: copy
        - value: move
        - value: test
    patchSchema:
      type: object
      properties:
        path:
          type: string
          description: The path to the property to operate on
        op:
          $ref: '#/components/schemas/PatchSchemaOp'
          description: The kind of operation to perform
        from:
          type: string
          description: >-
            The target to move or copy from, if performing one of those
            operations
        value:
          description: The value to add or replace, if performing one of those operations
      required:
        - path
        - op
    patchesSchema:
      type: array
      items:
        $ref: '#/components/schemas/patchSchema'
    VariantSchemaWeightType:
      type: string
      enum:
        - value: variable
        - value: fix
    VariantSchemaPayloadType:
      type: string
      enum:
        - value: json
        - value: csv
        - value: string
        - value: number
    VariantSchemaPayload:
      type: object
      properties:
        type:
          $ref: '#/components/schemas/VariantSchemaPayloadType'
          description: >-
            The type of the value. Commonly used types are string, number, json
            and csv.
        value:
          type: string
          description: The actual value of payload
      required:
        - type
        - value
    overrideSchema:
      type: object
      properties:
        contextName:
          type: string
          description: The name of the context field used to determine overrides
        values:
          type: array
          items:
            type: string
          description: Which values that should be overriden
      required:
        - contextName
        - values
    variantSchema:
      type: object
      properties:
        name:
          type: string
          description: The variants name. Is unique for this feature flag
        weight:
          type: number
          format: double
          description: >-
            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:
          $ref: '#/components/schemas/VariantSchemaWeightType'
          description: >-
            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
        stickiness:
          type: string
          description: >-
            [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:
          $ref: '#/components/schemas/VariantSchemaPayload'
          description: Extra data configured for this variant
        overrides:
          type: array
          items:
            $ref: '#/components/schemas/overrideSchema'
          description: >-
            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.
      required:
        - name
        - weight
    featureVariantsSchema:
      type: object
      properties:
        version:
          type: integer
          description: The version of the feature variants schema.
        variants:
          type: array
          items:
            $ref: '#/components/schemas/variantSchema'
          description: All variants defined for a specific feature flag.
      required:
        - version
        - variants

```

## SDK Code Examples

```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()
```