> 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 full documentation content, see https://docs.getunleash.io/llms-full.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.getunleash.io/_mcp/server.

# [BETA] Set the external impact-metrics source.

POST https://app.unleash-instance.example.com/api/admin/impact-metrics/external-source
Content-Type: application/json

**Enterprise feature**

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

Updates the configuration of the external impact-metrics source (any Prometheus-compatible endpoint).

Reference: https://docs.getunleash.io/api/set-external-impact-metrics-source

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: admin-api
  version: 1.0.0
paths:
  /api/admin/impact-metrics/external-source:
    post:
      operationId: set-external-impact-metrics-source
      summary: '[BETA] Set the external impact-metrics source.'
      description: >-
        **Enterprise feature**


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


        Updates the configuration of the external impact-metrics source (any
        Prometheus-compatible endpoint).
      tags:
        - subpackage_metrics
      parameters:
        - name: Authorization
          in: header
          description: API key needed to access this API
          required: true
          schema:
            type: string
      responses:
        '200':
          description: This response has no body.
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/Metrics_setExternalImpactMetricsSource_Response_200
        '400':
          description: The request data does not match what we expect.
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/SetExternalImpactMetricsSourceRequestBadRequestError
        '401':
          description: >-
            Authorization information is missing or invalid. Provide a valid API
            token as the `authorization` header, e.g.
            `authorization:*.*.my-admin-token`.
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/SetExternalImpactMetricsSourceRequestUnauthorizedError
        '403':
          description: >-
            The provided user credentials are valid, but the user does not have
            the necessary permissions to perform this operation
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/SetExternalImpactMetricsSourceRequestForbiddenError
        '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:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/SetExternalImpactMetricsSourceRequestUnsupportedMediaTypeError
      requestBody:
        description: setExternalImpactMetricsSourceSchema
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/setExternalImpactMetricsSourceSchema'
servers:
  - url: https://app.unleash-instance.example.com
    description: Your Unleash instance (replace with your actual URL)
components:
  schemas:
    setExternalImpactMetricsSourceSchema:
      type: object
      properties:
        enabled:
          type: boolean
          description: >-
            Whether the external impact-metrics source is active. When `true`,
            `url` must be a valid non-empty URL.
        url:
          type: string
          description: >-
            Base URL of the external impact-metrics source. Basic-Auth
            credentials may be embedded in the URL (e.g.
            `https://user:pass@metrics.example.com`); they are extracted into an
            `Authorization` header on outbound requests. Required (non-empty,
            valid URL) when `enabled` is true; an empty string is discarded when
            `enabled` is false.
      required:
        - enabled
      description: >-
        Configuration for connecting to an external impact-metrics source (any
        Prometheus-compatible endpoint). A valid URL must be supplied whenever
        `enabled` is true, including when re-enabling after a previous disable.
      title: setExternalImpactMetricsSourceSchema
    Metrics_setExternalImpactMetricsSource_Response_200:
      type: object
      properties: {}
      description: Empty response body
      title: Metrics_setExternalImpactMetricsSource_Response_200
    SetExternalImpactMetricsSourceRequestBadRequestError:
      type: object
      properties:
        id:
          type: string
          description: The ID of the error instance
        name:
          type: string
          description: The name of the error kind
        message:
          type: string
          description: A description of what went wrong.
      title: SetExternalImpactMetricsSourceRequestBadRequestError
    SetExternalImpactMetricsSourceRequestUnauthorizedError:
      type: object
      properties:
        id:
          type: string
          description: The ID of the error instance
        name:
          type: string
          description: The name of the error kind
        message:
          type: string
          description: A description of what went wrong.
      title: SetExternalImpactMetricsSourceRequestUnauthorizedError
    SetExternalImpactMetricsSourceRequestForbiddenError:
      type: object
      properties:
        id:
          type: string
          description: The ID of the error instance
        name:
          type: string
          description: The name of the error kind
        message:
          type: string
          description: A description of what went wrong.
      title: SetExternalImpactMetricsSourceRequestForbiddenError
    SetExternalImpactMetricsSourceRequestUnsupportedMediaTypeError:
      type: object
      properties:
        id:
          type: string
          description: The ID of the error instance
        name:
          type: string
          description: The name of the error kind
        message:
          type: string
          description: A description of what went wrong.
      title: SetExternalImpactMetricsSourceRequestUnsupportedMediaTypeError
  securitySchemes:
    apiKey:
      type: apiKey
      in: header
      name: Authorization
      description: API key needed to access this API
    bearerToken:
      type: http
      scheme: bearer
      description: API key needed to access this API, in Bearer token format

```

## Examples



**Request**

```json
{
  "enabled": true,
  "url": "https://prometheus.metrics.unleash.io"
}
```

**Response**

```json
{}
```

**SDK Code**

```python
import requests

url = "https://app.unleash-instance.example.com/api/admin/impact-metrics/external-source"

payload = {
    "enabled": True,
    "url": "https://prometheus.metrics.unleash.io"
}
headers = {
    "Authorization": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://app.unleash-instance.example.com/api/admin/impact-metrics/external-source';
const options = {
  method: 'POST',
  headers: {Authorization: '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"enabled":true,"url":"https://prometheus.metrics.unleash.io"}'
};

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/impact-metrics/external-source"

	payload := strings.NewReader("{\n  \"enabled\": true,\n  \"url\": \"https://prometheus.metrics.unleash.io\"\n}")

	req, _ := http.NewRequest("POST", 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/impact-metrics/external-source")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"enabled\": true,\n  \"url\": \"https://prometheus.metrics.unleash.io\"\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.post("https://app.unleash-instance.example.com/api/admin/impact-metrics/external-source")
  .header("Authorization", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"enabled\": true,\n  \"url\": \"https://prometheus.metrics.unleash.io\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.unleash-instance.example.com/api/admin/impact-metrics/external-source', [
  'body' => '{
  "enabled": true,
  "url": "https://prometheus.metrics.unleash.io"
}',
  '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/impact-metrics/external-source");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"enabled\": true,\n  \"url\": \"https://prometheus.metrics.unleash.io\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "enabled": true,
  "url": "https://prometheus.metrics.unleash.io"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.unleash-instance.example.com/api/admin/impact-metrics/external-source")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()
```