> 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] Validate an external impact-metrics source URL.

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

**Enterprise feature**

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

Tests an external impact-metrics source URL on the fly without persisting it. Returns the list of metric names found at the URL on success, or an `error` string explaining what went wrong. Always responds with 200; failures are reported in the body.

Reference: https://docs.getunleash.io/api/validate-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/validate:
    post:
      operationId: validate-external-impact-metrics-source
      summary: '[BETA] Validate an external impact-metrics source URL.'
      description: >-
        **Enterprise feature**


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


        Tests an external impact-metrics source URL on the fly without
        persisting it. Returns the list of metric names found at the URL on
        success, or an `error` string explaining what went wrong. Always
        responds with 200; failures are reported in the body.
      tags:
        - subpackage_metrics
      parameters:
        - name: Authorization
          in: header
          description: API key needed to access this API
          required: true
          schema:
            type: string
      responses:
        '200':
          description: validateExternalImpactMetricsSourceResultSchema
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/validateExternalImpactMetricsSourceResultSchema
        '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/ValidateExternalImpactMetricsSourceRequestUnauthorizedError
        '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/ValidateExternalImpactMetricsSourceRequestForbiddenError
        '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/ValidateExternalImpactMetricsSourceRequestUnsupportedMediaTypeError
      requestBody:
        description: validateExternalImpactMetricsSourceSchema
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/validateExternalImpactMetricsSourceSchema'
servers:
  - url: https://app.unleash-instance.example.com
    description: Your Unleash instance (replace with your actual URL)
components:
  schemas:
    validateExternalImpactMetricsSourceSchema:
      type: object
      properties:
        url:
          type: string
          description: >-
            Base URL of the external impact-metrics source to test. 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:
        - url
      description: >-
        Request body for validating an external impact-metrics source URL. The
        URL is checked on the fly and is not persisted.
      title: validateExternalImpactMetricsSourceSchema
    validateExternalImpactMetricsSourceResultSchema:
      type: object
      properties:
        metrics:
          type: array
          items:
            type: string
          description: >-
            List of metric names discovered at the supplied URL. Empty when the
            URL could not be validated.
        error:
          type: string
          description: >-
            Human-readable explanation of why the URL could not be validated.
            Omitted on success.
      required:
        - metrics
      description: >-
        Result of validating an external impact-metrics source URL. The endpoint
        always returns 200; failures are reported in the `error` field while
        `metrics` is empty.
      title: validateExternalImpactMetricsSourceResultSchema
    ValidateExternalImpactMetricsSourceRequestUnauthorizedError:
      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: ValidateExternalImpactMetricsSourceRequestUnauthorizedError
    ValidateExternalImpactMetricsSourceRequestForbiddenError:
      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: ValidateExternalImpactMetricsSourceRequestForbiddenError
    ValidateExternalImpactMetricsSourceRequestUnsupportedMediaTypeError:
      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: ValidateExternalImpactMetricsSourceRequestUnsupportedMediaTypeError
  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
{
  "url": "https://metrics.example.com"
}
```

**Response**

```json
{
  "metrics": [
    "http_requests_total",
    "process_cpu_seconds_total"
  ],
  "error": "External source returned HTTP 401"
}
```

**SDK Code**

```python
import requests

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

payload = { "url": "https://metrics.example.com" }
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/validate';
const options = {
  method: 'POST',
  headers: {Authorization: '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"url":"https://metrics.example.com"}'
};

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/validate"

	payload := strings.NewReader("{\n  \"url\": \"https://metrics.example.com\"\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/validate")

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  \"url\": \"https://metrics.example.com\"\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/validate")
  .header("Authorization", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"url\": \"https://metrics.example.com\"\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/validate', [
  'body' => '{
  "url": "https://metrics.example.com"
}',
  '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/validate");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"url\": \"https://metrics.example.com\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = ["url": "https://metrics.example.com"] 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/validate")! 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()
```