# Update a strategy

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

Replace strategy configuration for a feature flag in the specified environment.

Reference: https://docs.getunleash.io/api/update-feature-strategy

## OpenAPI Specification

```yaml
openapi: 3.1.1
info:
  title: Update a strategy
  version: endpoint_features.updateFeatureStrategy
paths:
  /api/admin/projects/{projectId}/features/{featureName}/environments/{environment}/strategies/{strategyId}:
    put:
      operationId: update-feature-strategy
      summary: Update a strategy
      description: >-
        Replace strategy configuration for a feature flag in the specified
        environment.
      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: strategyId
          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: featureStrategySchema
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/featureStrategySchema'
        '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: {}
        '415':
          description: >-
            The operation does not support request payloads of the provided
            type. Please ensure that you're using one of the listed payload
            types and that you have specified the right content type in the
            "content-type" header.
          content: {}
      requestBody:
        description: updateFeatureStrategySchema
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/updateFeatureStrategySchema'
components:
  schemas:
    ConstraintSchemaOperator:
      type: string
      enum:
        - value: NOT_IN
        - value: IN
        - value: STR_ENDS_WITH
        - value: STR_STARTS_WITH
        - value: STR_CONTAINS
        - value: NUM_EQ
        - value: NUM_GT
        - value: NUM_GTE
        - value: NUM_LT
        - value: NUM_LTE
        - value: DATE_AFTER
        - value: DATE_BEFORE
        - value: SEMVER_EQ
        - value: SEMVER_GT
        - value: SEMVER_LT
    constraintSchema:
      type: object
      properties:
        contextName:
          type: string
          description: The name of the context field that this constraint should apply to.
        operator:
          $ref: '#/components/schemas/ConstraintSchemaOperator'
          description: >-
            The operator to use when evaluating this constraint. For more
            information about the various operators, refer to [the strategy
            constraint operator
            documentation](https://docs.getunleash.io/concepts/activation-strategies#constraint-operators).
        caseInsensitive:
          type: boolean
          default: false
          description: >-
            Whether the operator should be case sensitive or not. Defaults to
            `false` (being case sensitive).
        inverted:
          type: boolean
          default: false
          description: >-
            Whether the result should be negated or not. If `true`, will turn a
            `true` result into a `false` result and vice versa.
        values:
          type: array
          items:
            type: string
          description: >-
            The context values that should be used for constraint evaluation.
            Use this property instead of `value` for properties that accept
            multiple values.
        value:
          type: string
          description: >-
            The context value that should be used for constraint evaluation. Use
            this property instead of `values` for properties that only accept
            single values.
      required:
        - contextName
        - operator
    StrategyVariantSchemaWeightType:
      type: string
      enum:
        - value: variable
        - value: fix
    StrategyVariantSchemaPayloadType:
      type: string
      enum:
        - value: json
        - value: csv
        - value: string
        - value: number
    StrategyVariantSchemaPayload:
      type: object
      properties:
        type:
          $ref: '#/components/schemas/StrategyVariantSchemaPayloadType'
          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
    strategyVariantSchema:
      type: object
      properties:
        name:
          type: string
          description: The variant name. Must be unique for this feature flag
        weight:
          type: integer
          description: >-
            The weight is the likelihood of any one user getting this variant.
            It is an integer 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/StrategyVariantSchemaWeightType'
          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. Refer to the [variant
            weight
            documentation](https://docs.getunleash.io/concepts/feature-flag-variants#variant-weight).
        stickiness:
          type: string
          description: >-
            The
            [stickiness](https://docs.getunleash.io/concepts/feature-flag-variants#variant-stickiness)
            to use for distribution of this variant. Stickiness is how Unleash
            guarantees that the same user gets the same variant every time
        payload:
          $ref: '#/components/schemas/StrategyVariantSchemaPayload'
          description: Extra data configured for this variant
      required:
        - name
        - weight
        - weightType
        - stickiness
    parametersSchema:
      type: object
      additionalProperties:
        type: string
    updateFeatureStrategySchema:
      type: object
      properties:
        name:
          type: string
          description: The name of the strategy type
        sortOrder:
          type: number
          format: double
          description: >-
            The order of the strategy in the list in feature environment
            configuration
        constraints:
          type: array
          items:
            $ref: '#/components/schemas/constraintSchema'
          description: >-
            A list of the constraints attached to the strategy. See
            https://docs.getunleash.io/concepts/activation-strategies#constraints
        title:
          type:
            - string
            - 'null'
          description: A descriptive title for the strategy
        disabled:
          type:
            - boolean
            - 'null'
          description: >-
            A toggle to disable the strategy. defaults to true. Disabled
            strategies are not evaluated or returned to the SDKs
        variants:
          type: array
          items:
            $ref: '#/components/schemas/strategyVariantSchema'
          description: Strategy level variants
        segments:
          type: array
          items:
            type: number
            format: double
          description: A list of segment ids attached to the strategy
        parameters:
          $ref: '#/components/schemas/parametersSchema'
    featureStrategySchema:
      type: object
      properties:
        id:
          type: string
          description: A uuid for the feature strategy
        name:
          type: string
          description: The name or type of strategy
        title:
          type:
            - string
            - 'null'
          description: A descriptive title for the strategy
        disabled:
          type:
            - boolean
            - 'null'
          description: >-
            A toggle to disable the strategy. defaults to false. Disabled
            strategies are not evaluated or returned to the SDKs
        featureName:
          type: string
          description: The name or feature the strategy is attached to
        sortOrder:
          type: number
          format: double
          description: The order of the strategy in the list
        segments:
          type: array
          items:
            type: number
            format: double
          description: A list of segment ids attached to the strategy
        constraints:
          type: array
          items:
            $ref: '#/components/schemas/constraintSchema'
          description: >-
            A list of the constraints attached to the strategy. See
            https://docs.getunleash.io/concepts/activation-strategies#constraints
        variants:
          type: array
          items:
            $ref: '#/components/schemas/strategyVariantSchema'
          description: Strategy level variants
        parameters:
          $ref: '#/components/schemas/parametersSchema'
      required:
        - name

```

## SDK Code Examples

```python
import requests

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

payload = {}
headers = {
    "Authorization": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.put(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/strategies/strategyId';
const options = {
  method: 'PUT',
  headers: {Authorization: '<apiKey>', 'Content-Type': 'application/json'},
  body: '{}'
};

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/strategies/strategyId"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("PUT", 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/strategies/strategyId")

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

request = Net::HTTP::Put.new(url)
request["Authorization"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{}"

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.put("https://app.unleash-instance.example.com/api/admin/projects/projectId/features/featureName/environments/environment/strategies/strategyId")
  .header("Authorization", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://app.unleash-instance.example.com/api/admin/projects/projectId/features/featureName/environments/environment/strategies/strategyId', [
  'body' => '{}',
  '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/strategies/strategyId");
var request = new RestRequest(Method.PUT);
request.AddHeader("Authorization", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [] 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/strategies/strategyId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```