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

# Change specific properties of a strategy

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

Change specific properties of a strategy configuration in a feature flag.

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

## 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)
- `strategyId` (string, required)

### Body (application/json)

This endpoint expects a list of patchSchema.

- `list of patchSchema`

## Response

### 200

featureStrategySchema

- `name` (string, required) — The name or type of strategy
- `id` (string, optional) — A uuid for the feature strategy
- `title` (string, optional, nullable) — A descriptive title for the strategy
- `disabled` (boolean, optional, nullable) — A toggle to disable the strategy. defaults to false. Disabled strategies are not evaluated or returned to the SDKs
- `featureName` (string, optional) — The name or feature the strategy is attached to
- `sortOrder` (double, optional) — The order of the strategy in the list
- `segments` (list of double, optional) — A list of segment ids attached to the strategy
- `constraints` (list of constraintSchema, optional) — A list of the constraints attached to the strategy. See https://docs.getunleash.io/concepts/activation-strategies#constraints
- `variants` (list of strategyVariantSchema, optional) — Strategy level variants
- `parameters` (map from string to string, optional) — A list of parameters for a strategy

## 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.

### 415 Unsupported Media Type Error

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.

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

### constraintSchema

A strategy constraint. For more information, refer to [the strategy constraint reference documentation](https://docs.getunleash.io/concepts/activation-strategies#constraints)

- `contextName` (string, required) — The name of the context field that this constraint should apply to.
- `operator` (enum, required) — 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).
  - Allowed values: `NOT_IN`, `IN`, `STR_ENDS_WITH`, `STR_STARTS_WITH`, `STR_CONTAINS`, `NUM_EQ`, `NUM_GT`, `NUM_GTE`, `NUM_LT`, `NUM_LTE`, `DATE_AFTER`, `DATE_BEFORE`, `SEMVER_EQ`, `SEMVER_GT`, `SEMVER_LT`, `SEMVER_GTE`, `SEMVER_LTE`, `REGEX`
- `caseInsensitive` (boolean, optional, default: false) — Whether the operator should be case sensitive or not. Defaults to `false` (being case sensitive).
- `inverted` (boolean, optional, default: false) — Whether the result should be negated or not. If `true`, will turn a `true` result into a `false` result and vice versa.
- `values` (list of string, optional) — The context values that should be used for constraint evaluation. Use this property instead of `value` for properties that accept multiple values.
- `value` (string, optional) — The context value that should be used for constraint evaluation. Use this property instead of `values` for properties that only accept single values.

### strategyVariantSchema

This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.

- `name` (string, required) — The variant name. Must be unique for this feature flag
- `weight` (integer, required) — 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` (enum, required) — 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).
  - Allowed values: `variable`, `fix`
- `stickiness` (string, required) — 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` (StrategyVariantSchemaPayload, optional) — Extra data configured for this variant

### StrategyVariantSchemaPayload

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

## Examples

**Request**

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

**Response**

```json
{
  "name": "flexibleRollout",
  "id": "6b5157cb-343a-41e7-bfa3-7b4ec3044840",
  "title": "Gradual Rollout 25-Prod",
  "disabled": false,
  "featureName": "myAwesomeFeature",
  "sortOrder": 9999,
  "segments": [
    1,
    2
  ],
  "constraints": [
    {
      "contextName": "appName",
      "operator": "IN",
      "caseInsensitive": false,
      "inverted": false,
      "values": [
        "my-app",
        "my-other-app"
      ],
      "value": "my-app"
    }
  ],
  "variants": [
    {
      "name": "blue_group",
      "weight": 1,
      "weightType": "fix",
      "stickiness": "custom.context.field",
      "payload": {
        "type": "json",
        "value": "{\"color\": \"red\"}"
      }
    }
  ],
  "parameters": {}
}
```

**SDK Code**

```python
import requests

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

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

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

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/strategies/strategyId")
  .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/strategies/strategyId', [
  '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/strategies/strategyId");
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/strategies/strategyId")! 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()
```