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

# [BETA] Get partial updates (SDK)

GET https://app.unleash-instance.example.com/api/client/delta

**Enterprise feature**

**[BETA]** This API is in beta state, which means it may change or be removed in the future.

Initially returns the full set of feature flags available to the provided API key. When called again with the returned etag, only returns the flags that have changed

Reference: https://docs.getunleash.io/api/get-delta

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

## Response

### 200

clientFeaturesDeltaSchema

- `events` (list of ClientFeaturesDeltaSchemaEventsItems, required) — A list of delta events.

## Types

### ClientFeaturesDeltaSchemaEventsItems

### ClientFeaturesDeltaSchemaEventsItems0

- `eventId` (double, required)
- `type` (enum, required)
  - Allowed values: `feature-updated`
- `feature` (clientFeatureSchema, required) — Feature flag configuration used by SDKs to evaluate state of a flag

### ClientFeaturesDeltaSchemaEventsItems1

- `eventId` (double, required)
- `type` (enum, required)
  - Allowed values: `feature-removed`
- `featureName` (string, required)
- `project` (string, required)

### ClientFeaturesDeltaSchemaEventsItems2

- `eventId` (double, required)
- `type` (enum, required)
  - Allowed values: `segment-updated`
- `segment` (clientSegmentSchema, required) — Represents a client API segment of users defined by a set of constraints.

### ClientFeaturesDeltaSchemaEventsItems3

- `eventId` (double, required)
- `type` (enum, required)
  - Allowed values: `segment-removed`
- `segmentId` (double, required)

### ClientFeaturesDeltaSchemaEventsItems4

- `eventId` (double, required)
- `type` (enum, required)
  - Allowed values: `hydration`
- `features` (list of clientFeatureSchema, required)
- `segments` (list of clientSegmentSchema, required)

### clientFeatureSchema

Feature flag configuration used by SDKs to evaluate state of a flag

- `name` (string, required) — The unique name of a feature flag. Is validated to be URL safe on creation
- `enabled` (boolean, required) — Whether the feature flag is enabled for the current API key or not. This is ANDed with the evaluation results of the strategies list, so if this is false, the evaluation result will always be false
- `type` (string, optional) — What kind of feature flag is this. Refer to the documentation on [feature flag types](https://docs.getunleash.io/concepts/feature-flags#feature-flag-types) for more information
- `description` (string, optional, nullable) — A description of the flag
- `stale` (boolean, optional) — If this is true Unleash believes this feature flag has been active longer than Unleash expects a flag of this type to be active
- `impressionData` (boolean, optional, nullable) — Set to true if SDKs should trigger [impression events](https://docs.getunleash.io/concepts/impression-data) when this flag is evaluated
- `project` (string, optional) — Which project this feature flag belongs to
- `strategies` (list of featureStrategySchema, optional) — Evaluation strategies for this flag. Each entry in this list will be evaluated and ORed together
- `variants` (list of variantSchema, optional, nullable) — [Variants](https://docs.getunleash.io/concepts/feature-flag-variants#what-are-variants) configured for this flag
- `dependencies` (list of dependentFeatureSchema, optional) — Feature dependencies for this flag

### clientSegmentSchema

Represents a client API segment of users defined by a set of constraints.

- `id` (double, required) — The segment's id.
- `constraints` (list of constraintSchema, required) — List of constraints that determine which users are part of the segment
- `name` (string, optional) — The name of the segment.

### featureStrategySchema

A single activation strategy configuration schema for a feature

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

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

### dependentFeatureSchema

Feature dependency on a parent feature in read model

- `feature` (string, required) — The name of the feature we depend on.
- `enabled` (boolean, optional) — Whether the parent feature should be enabled. When `false` variants are ignored. `true` by default.
- `variants` (list of string, optional) — The list of variants the parent feature should resolve to. Leave empty when you only want to check the `enabled` status.

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

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

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

**Response**

```json
{
  "events": [
    {
      "eventId": 1.1,
      "feature": {
        "dependencies": [
          {
            "enabled": false,
            "feature": "parent_feature",
            "variants": [
              "variantA",
              "variantB"
            ]
          }
        ],
        "description": "No variants here",
        "enabled": true,
        "impressionData": false,
        "name": "new.payment.flow.stripe",
        "project": "new.payment.flow",
        "stale": false,
        "strategies": [
          {
            "constraints": [
              {
                "caseInsensitive": false,
                "contextName": "appName",
                "inverted": false,
                "operator": "IN",
                "value": "my-app",
                "values": [
                  "my-app",
                  "my-other-app"
                ]
              }
            ],
            "disabled": false,
            "featureName": "myAwesomeFeature",
            "id": "6b5157cb-343a-41e7-bfa3-7b4ec3044840",
            "name": "flexibleRollout",
            "parameters": {},
            "segments": [
              1,
              2
            ],
            "sortOrder": 9999,
            "title": "Gradual Rollout 25-Prod",
            "variants": [
              {
                "name": "blue_group",
                "payload": {
                  "type": "json",
                  "value": "{\"color\": \"red\"}"
                },
                "stickiness": "custom.context.field",
                "weight": 1,
                "weightType": "fix"
              }
            ]
          }
        ],
        "type": "release",
        "variants": [
          {
            "name": "blue_group",
            "overrides": [
              {
                "contextName": "userId",
                "values": [
                  "red",
                  "blue"
                ]
              }
            ],
            "payload": {
              "type": "json",
              "value": "{\"color\": \"red\"}"
            },
            "stickiness": "custom.context.field",
            "weight": 1.1,
            "weightType": "variable"
          }
        ]
      },
      "type": "feature-updated"
    }
  ]
}
```

**SDK Code**

```python
import requests

url = "https://app.unleash-instance.example.com/api/client/delta"

headers = {"Authorization": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript
const url = 'https://app.unleash-instance.example.com/api/client/delta';
const options = {method: 'GET', headers: {Authorization: '<apiKey>'}};

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"
	"net/http"
	"io"
)

func main() {

	url := "https://app.unleash-instance.example.com/api/client/delta"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "<apiKey>")

	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/client/delta")

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = '<apiKey>'

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.get("https://app.unleash-instance.example.com/api/client/delta")
  .header("Authorization", "<apiKey>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://app.unleash-instance.example.com/api/client/delta', [
  'headers' => [
    'Authorization' => '<apiKey>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://app.unleash-instance.example.com/api/client/delta");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Authorization": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://app.unleash-instance.example.com/api/client/delta")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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