# Get all flags (SDK)

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

Returns the SDK configuration for all feature flags that are available to the provided API key. Used by SDKs to configure local evaluation

Reference: https://docs.getunleash.io/api/get-all-client-features

## OpenAPI Specification

```yaml
openapi: 3.1.1
info:
  title: Get all flags (SDK)
  version: endpoint_client.getAllClientFeatures
paths:
  /api/client/features:
    get:
      operationId: get-all-client-features
      summary: Get all flags (SDK)
      description: >-
        Returns the SDK configuration for all feature flags that are available
        to the provided API key. Used by SDKs to configure local evaluation
      tags:
        - - subpackage_client
      parameters:
        - name: Authorization
          in: header
          description: Header authentication of the form `undefined <token>`
          required: true
          schema:
            type: string
      responses:
        '200':
          description: clientFeaturesSchema
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/clientFeaturesSchema'
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
    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
    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
    dependentFeatureSchema:
      type: object
      properties:
        feature:
          type: string
          description: The name of the feature we depend on.
        enabled:
          type: boolean
          description: >-
            Whether the parent feature should be enabled. When `false` variants
            are ignored. `true` by default.
        variants:
          type: array
          items:
            type: string
          description: >-
            The list of variants the parent feature should resolve to. Leave
            empty when you only want to check the `enabled` status.
      required:
        - feature
    clientFeatureSchema:
      type: object
      properties:
        name:
          type: string
          description: >-
            The unique name of a feature flag. Is validated to be URL safe on
            creation
        type:
          type: string
          description: >-
            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:
          type:
            - string
            - 'null'
          description: A description of the flag
        enabled:
          type: boolean
          description: >-
            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
        stale:
          type: boolean
          description: >-
            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:
          type:
            - boolean
            - 'null'
          description: >-
            Set to true if SDKs should trigger [impression
            events](https://docs.getunleash.io/concepts/impression-data) when
            this flag is evaluated
        project:
          type: string
          description: Which project this feature flag belongs to
        strategies:
          type: array
          items:
            $ref: '#/components/schemas/featureStrategySchema'
          description: >-
            Evaluation strategies for this flag. Each entry in this list will be
            evaluated and ORed together
        variants:
          type:
            - array
            - 'null'
          items:
            $ref: '#/components/schemas/variantSchema'
          description: >-
            [Variants](https://docs.getunleash.io/concepts/feature-flag-variants#what-are-variants)
            configured for this flag
        dependencies:
          type: array
          items:
            $ref: '#/components/schemas/dependentFeatureSchema'
          description: Feature dependencies for this flag
      required:
        - name
        - enabled
    clientSegmentSchema:
      type: object
      properties:
        id:
          type: number
          format: double
          description: The segment's id.
        name:
          type: string
          description: The name of the segment.
        constraints:
          type: array
          items:
            $ref: '#/components/schemas/constraintSchema'
          description: >-
            List of constraints that determine which users are part of the
            segment
      required:
        - id
        - constraints
    clientFeaturesQuerySchema:
      type: object
      properties:
        tag:
          type: array
          items:
            type: array
            items:
              type: string
          description: Features tagged with one of these tags are included
        project:
          type: array
          items:
            type: string
          description: >-
            Features that are part of these projects are included in this
            response. This is now handled by API tokens and was marked as
            deprecated in v5
        namePrefix:
          type: string
          description: >-
            Features are filtered to only include features whose name starts
            with this prefix
        environment:
          type: string
          description: >-
            Strategies for the feature flag configured for this environment are
            included. This is now handled by API tokens and was marked as
            deprecated in v5
        inlineSegmentConstraints:
          type: boolean
          description: >-
            Set to true if requesting client does not support
            Unleash-Client-Specification 4.2.2 or newer. Modern SDKs will have
            this set to false, since they will be able to merge constraints and
            segments themselves
    clientFeaturesSchema:
      type: object
      properties:
        version:
          type: number
          format: double
          description: >-
            A version number for the format used in the response. Most Unleash
            instances now return version 2, which includes segments as a
            separate array
        features:
          type: array
          items:
            $ref: '#/components/schemas/clientFeatureSchema'
          description: A list of feature flags with their configuration
        segments:
          type: array
          items:
            $ref: '#/components/schemas/clientSegmentSchema'
          description: >-
            A list of [Segments](https://docs.getunleash.io/concepts/segments)
            configured for this Unleash instance
        query:
          $ref: '#/components/schemas/clientFeaturesQuerySchema'
          description: >-
            A summary of filters and parameters sent to the endpoint. Used by
            the server to build the features and segments response
      required:
        - version
        - features

```

## SDK Code Examples

```python
import requests

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

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

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

print(response.json())
```

```javascript
const url = 'https://app.unleash-instance.example.com/api/client/features';
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/features"

	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/features")

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/features")
  .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/features', [
  'headers' => [
    'Authorization' => '<apiKey>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://app.unleash-instance.example.com/api/client/features");
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/features")! 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()
```