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

# Get UI configuration

GET https://app.unleash-instance.example.com/api/admin/ui-config

Retrieves the full configuration used to set up the Unleash Admin UI.

Reference: https://docs.getunleash.io/api/get-ui-config

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

uiConfigSchema

- `version` (string, required) — The current version of Unleash
- `unleashUrl` (string, required) — The URL of the Unleash instance.
- `baseUriPath` (string, required) — The base URI path at which this Unleash instance is listening.
- `versionInfo` (object, required) — Detailed information about an Unleash version
  - `current` (object, required) — The current version of Unleash.
    - `oss` (string, optional) — The OSS version used when building this Unleash instance, represented as a git revision belonging to the [main Unleash git repo](https://github.com/Unleash/unleash/)
    - `enterprise` (string, optional) — The Enterpris version of Unleash used to build this instance, represented as a git revision belonging to the [Unleash Enterprise](https://github.com/ivarconr/unleash-enterprise) repository. Will be an empty string if no enterprise version was used,
  - `latest` (object, required) — Information about the latest available Unleash releases. Will be an empty object if no data is available.
    - `oss` (string, optional) — The latest available OSS version of Unleash
    - `enterprise` (string, optional) — The latest available Enterprise version of Unleash
  - `isLatest` (boolean, required) — Whether the Unleash server is running the latest release (`true`) or if there are updates available (`false`)
  - `instanceId` (string, optional) — The instance identifier of the Unleash instance
  - `buildDate` (string, optional, nullable) — The date and time of when this Unleash instance version was built
- `slogan` (string, optional) — The slogan to display in the UI footer.
- `name` (string, optional) — The name of this Unleash instance. Used to build the text in the footer.
- `environment` (string, optional) — What kind of Unleash instance it is: Enterprise, Pro, or Open source
- `billing` (enum, optional) — The billing model in use for this Unleash instance.
  - Allowed values: `subscription`, `pay-as-you-go`
- `edgeUrl` (string, optional) — The URL of the Unleash Edge instance.
- `logRocketAppId` (string, optional) — The LogRocket app ID used to initialize session replay in the admin UI. Only used when the `logRocketEnabled` flag is on.
- `hubspotPortalId` (string, optional) — The HubSpot portal ID. Currently used to load the customer support chat widget when the `hubspotChatEnabled` flag is on and the instance is a PAYG trial; may be reused by future HubSpot integrations.
- `feedbackUriPath` (string, optional) — The URI path at which the feedback endpoint is listening.
- `disablePasswordAuth` (boolean, optional) — Whether password authentication should be disabled or not.
- `emailEnabled` (boolean, optional) — Whether this instance can send out emails or not.
- `maintenanceMode` (boolean, optional) — Whether maintenance mode is currently active or not.
- `resourceLimits` (object, optional) — A map of resource names and their limits.
  - `segmentValues` (integer, required) — The maximum number of values per segment allowed.
  - `strategySegments` (integer, required) — The maximum number of strategy segments allowed.
  - `actionSetActions` (integer, required) — The maximum number of actions per action set allowed.
  - `actionSetsPerProject` (integer, required) — The maximum number of action set definitions per project allowed.
  - `actionSetFilters` (integer, required) — The maximum number of filters per action set allowed.
  - `actionSetFilterValues` (integer, required) — The maximum number of filter values inside an action set allowed.
  - `signalEndpoints` (integer, required) — The maximum number of signal endpoints allowed.
  - `signalTokensPerEndpoint` (integer, required) — The maximum number of signal tokens per endpoint allowed.
  - `featureEnvironmentStrategies` (integer, required) — The maximum number of feature environment strategies allowed.
  - `constraintValues` (integer, required) — The maximum number of values for a single constraint.
  - `constraints` (integer, required) — The maximum number of constraints in a single strategy.
  - `environments` (integer, required) — The maximum number of environments allowed.
  - `apiTokens` (integer, required) — The maximum number of SDK and admin API tokens you can have at the same time. This limit applies only to backend and frontend SDK tokens and to admin tokens. Personal access tokens are not subject to this limit. The limit applies to the total number of tokens across all projects in your organization.
  - `projects` (integer, required) — The maximum number of projects allowed.
  - `segments` (integer, required) — The maximum number of segments allowed.
  - `featureFlags` (integer, required) — The maximum number of feature flags you can have at the same time. Archived flags do not count towards this limit.
  - `releaseTemplates` (integer, required) — The maximum number of release templates allowed.
  - `readOnlyUsers` (integer, optional) — The maximum number of read-only users allowed.
- `prometheusAPIAvailable` (boolean, optional) — Whether a Prometheus API is available.
- `impactMetrics` (enum, optional) — Impact metrics availability for this instance. `disabled` when the killswitch is on; `unconfigured` when no source is set up yet; `internal`/`external`/`full` depending on which data sources are available.
  - Allowed values: `disabled`, `unconfigured`, `external`, `internal`, `full`
- `frontendApiOrigins` (list of string, optional) — The list of origins that the front-end API should accept requests from.
- `flags` (map from string to boolean or object, optional) — Additional (largely experimental) features that are enabled in this Unleash instance.
  - variantFlagSchema
    - `name` (string, optional) — The name of the variant. Will always be disabled if `enabled` is false.
    - `enabled` (boolean, optional) — Whether the variant is enabled or not.
    - `payload` (object, optional) — Additional data associated with this variant.
      - `type` (enum, optional) — The type of data contained.
        - Allowed values: `string`, `json`, `csv`, `number`
      - `value` (string, optional) — The actual associated data
    - `feature_enabled` (boolean, optional) — Whether the feature is enabled or not.
    - `featureEnabled` (boolean, optional, deprecated) — Use `feature_enabled` instead.
- `links` (list of object, optional) — Relevant links to use in the UI.
- `authenticationType` (enum, optional) — The type of authentication enabled for this Unleash instance
  - Allowed values: `open-source`, `demo`, `enterprise`, `hosted`, `custom`, `none`
- `oidcConfiguredThroughEnv` (boolean, optional) — Whether the OIDC configuration is set through environment variables or not.
- `samlConfiguredThroughEnv` (boolean, optional) — Whether the SAML configuration is set through environment variables or not.
- `maxSessionsCount` (double, optional) — The maximum number of sessions that a user has.
- `unleashContext` (object, optional) — The context object used to configure the Unleash instance.
- `storiesPageEnabled` (boolean, optional) — Whether the internal `/_stories` component gallery route is enabled. Controlled by the `ENABLE_STORIES_PAGE` environment variable.

## Examples

**Response**

```json
{
  "version": "5.3.0-main",
  "unleashUrl": "https://unleash.mycompany.com/enterprise",
  "baseUriPath": "/enterprise",
  "versionInfo": {
    "current": {
      "oss": "5.3.0-main",
      "enterprise": "5.3.0-main+2105.45ed03c9"
    },
    "latest": {
      "oss": "5.1.5",
      "enterprise": "5.1.5"
    },
    "isLatest": true,
    "instanceId": "0d652a82-43db-4144-8e02-864b0b030710",
    "buildDate": "2023-06-30T11:41:00.123Z"
  },
  "slogan": "The enterprise-ready feature flag service.",
  "name": "Unleash enterprise",
  "environment": "Enterprise",
  "billing": "subscription",
  "edgeUrl": "https://yourcompany.edge.getunleash.io",
  "logRocketAppId": "1knhci/unleash-sandbox",
  "hubspotPortalId": "1234567",
  "feedbackUriPath": "/feedback",
  "disablePasswordAuth": false,
  "emailEnabled": true,
  "maintenanceMode": false,
  "resourceLimits": {
    "segmentValues": 10,
    "strategySegments": 10,
    "actionSetActions": 10,
    "actionSetsPerProject": 10,
    "actionSetFilters": 10,
    "actionSetFilterValues": 10,
    "signalEndpoints": 10,
    "signalTokensPerEndpoint": 10,
    "featureEnvironmentStrategies": 30,
    "constraintValues": 250,
    "constraints": 30,
    "environments": 50,
    "apiTokens": 2000,
    "projects": 500,
    "segments": 300,
    "featureFlags": 5000,
    "releaseTemplates": 5,
    "readOnlyUsers": 50
  },
  "prometheusAPIAvailable": true,
  "impactMetrics": "internal",
  "frontendApiOrigins": [
    "*"
  ],
  "flags": {
    "featuresExportImport": true,
    "messageBanner": {
      "enabled": false,
      "name": "disabled"
    }
  },
  "links": [
    {
      "href": "https://docs.getunleash.io",
      "icon": "library_books",
      "title": "User documentation",
      "value": "Documentation"
    },
    {
      "href": "https://github.com/Unleash/unleash",
      "icon": "c_github",
      "title": "Source code on GitHub",
      "value": "GitHub"
    }
  ],
  "authenticationType": "enterprise",
  "oidcConfiguredThroughEnv": false,
  "samlConfiguredThroughEnv": false,
  "maxSessionsCount": 10,
  "unleashContext": {},
  "storiesPageEnabled": false
}
```

**SDK Code**

```python
import requests

url = "https://app.unleash-instance.example.com/api/admin/ui-config"

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

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

print(response.json())
```

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

	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/admin/ui-config")

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

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

```csharp
using RestSharp;

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