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

# Register client usage metrics

POST https://app.unleash-instance.example.com/api/frontend/client/metrics
Content-Type: application/json

Registers usage metrics. Stores information about how many times each flag was evaluated to enabled and disabled within a time frame. If provided, this operation will also store data on how many times each feature flag's variants were displayed to the end user. If the Frontend API is disabled 404 is returned.

Reference: https://docs.getunleash.io/api/register-frontend-metrics

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

## Request

### Body (application/json)

This endpoint expects a clientMetricsSchema.

- `appName` (string, required) — The name of the application that is evaluating toggles
- `instanceId` (string, optional) — A [(somewhat) unique identifier](https://docs.getunleash.io/sdks/node#advanced-usage) for the application
- `sdkVersion` (string, optional) — An SDK version identifier. Usually formatted as "unleash-client-\<language>:\<version>"
- `platformName` (string, optional) — The platform the application is running on. For languages that compile to binaries, this can be omitted
- `platformVersion` (string, optional) — The version of the platform the application is running on. Languages that compile to binaries, this is expected to be the compiler version used to assemble the binary.
- `yggdrasilVersion` (string, optional) — The semantic version of the Yggdrasil engine used by the client. If the client is using a native engine this can be omitted.
- `specVersion` (string, optional) — The version of the Unleash client specification the client supports
- `sdkFlavor` (string, optional) — The identifier of an integration built on top of an Unleash SDK (e.g. an OpenFeature provider). Sent so adoption of the integration can be tracked alongside sdkVersion.
- `sdkFlavorVersion` (string, optional) — The version of the integration identified by sdk flavor, that has been built on top of an Unleash SDK
- `bucket` (ClientMetricsSchemaBucket, optional, nullable) — Holds all metrics gathered over a window of time. Typically 1 hour wide. May be omitted or null when the request only carries impact metrics.

## Response

### 200

This response has no body.

## Errors

### 400 Bad Request Error

The request data does not match what we expect.

- `id` (string, optional) — The ID of the error instance
- `name` (string, optional) — The name of the error kind
- `message` (string, optional) — A description of what went wrong.

### 401 Unauthorized Error

Authorization information is missing or invalid. Provide a valid API token as the `authorization` header, e.g. `authorization:*.*.my-admin-token`.

- `id` (string, optional) — The ID of the error instance
- `name` (string, optional) — The name of the error kind
- `message` (string, optional) — A description of what went wrong.

### 404 Not Found Error

The requested resource was not found.

- `id` (string, optional) — The ID of the error instance
- `name` (string, optional) — The name of the error kind
- `message` (string, optional) — A description of what went wrong.

## Types

### ClientMetricsSchemaBucket

Holds all metrics gathered over a window of time. Typically 1 hour wide. May be omitted or null when the request only carries impact metrics.

- `start` (dateSchema, required) — The start of the time window these metrics are valid for. The window is usually 1 hour wide
- `stop` (dateSchema, required) — The end of the time window these metrics are valid for. The window is 1 hour wide
- `toggles` (map from string to ClientMetricsSchemaBucketToggles, required) — an object containing feature names with yes/no plus variant usage

### dateSchema

A representation of a date. Either as a date-time string or as a UNIX timestamp.

### ClientMetricsSchemaBucketToggles

- `yes` (double, optional) — How many times the toggle evaluated to true
- `no` (integer, optional) — How many times the toggle evaluated to false
- `variants` (map from string to integer, optional, nullable) — An object describing how many times each variant was returned. Variant names are used as properties, and the number of times they were exposed is the corresponding value (i.e. `{ [variantName]: number }`).

## Examples

**Request**

```json
{
  "appName": "insurance-selector"
}
```

**Response**

```json
{}
```

**SDK Code**

```python
import requests

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

payload = { "appName": "insurance-selector" }
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/frontend/client/metrics';
const options = {
  method: 'POST',
  headers: {Authorization: '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"appName":"insurance-selector"}'
};

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/frontend/client/metrics"

	payload := strings.NewReader("{\n  \"appName\": \"insurance-selector\"\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/frontend/client/metrics")

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  \"appName\": \"insurance-selector\"\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/frontend/client/metrics")
  .header("Authorization", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"appName\": \"insurance-selector\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.unleash-instance.example.com/api/frontend/client/metrics', [
  'body' => '{
  "appName": "insurance-selector"
}',
  'headers' => [
    'Authorization' => '<apiKey>',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://app.unleash-instance.example.com/api/frontend/client/metrics");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"appName\": \"insurance-selector\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = ["appName": "insurance-selector"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://app.unleash-instance.example.com/api/frontend/client/metrics")! 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()
```