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

# Get timeseries data

GET https://api.fastpix.com/v1/data/metrics/{metricId}/timeseries

This endpoint retrieves timeseries data for a specified metric, providing insights into how the metric values change over time. The response includes an array of data points, each representing the metrics value at specific intervals. 

#### Key fields in response

* **intervalTime:** The timestamp for the data point indicating when the metric value was recorded. 
* **metricValue:** The value of the specified metric at the given interval, reflecting the performance or engagement level during that time. 
* **numberOfViews:** The total number of views recorded during that interval, providing context for the metric value.


Reference: https://fastpix.com/docs/video-data-api/metrics/get-timeseries-data

## Authentication

- `Authorization` header (basic auth, required) — FastPix APIs are secured with Basic Authentication. Use your Access Token ID as the username and Secret Key as the password in the Authorization header of each API request. * Username: Access Token ID * Password: Secret Key Activate your FastPix account to generate your API credentials. See the guide here

## Request

### Path parameters

- `metricId` (enum, required) — Pass metric Id
  - Allowed values: `views`, `unique_viewers`, `playing_time`, `quality_of_experience_score`, `playback_score`, `playback_failure_percentage`, `exit_before_video_start`, `video_startup_failure_percentage`, `startup_score`, `video_startup_time`, `player_startup_time`, `page_load_time`, `total_startup_time`, `live_stream_latency`, `average_bitrate`, `buffer_count`, `render_quality_score`, `avg_upscaling`, `avg_downscaling`, `max_upscaling`, `max_downscaling`, `jump_latency`, `stability_score`, `buffer_ratio`, `buffer_frequency`, `buffer_fill`

### Query parameters

- `groupBy` (enum, optional, default: minute) — Pass this value to group the metrics list by.
  - Allowed values: `minute`, `ten_minutes`, `hour`, `day`
- `sortOrder` (enum, optional, default: asc) — The order direction to sort the metrics list by.
  - Allowed values: `asc`, `desc`
- `measurement` (string, optional, default: avg) — The measurement for the given metrics. Possible Values : [95th, median, avg, count or sum]
- `timespan[]` (enum, optional) — This parameter specifies the time span between which the video views list must be retrieved by. You can provide either from and to unix epoch timestamps or time duration. The scope of duration is between 60 minutes to 30 days. **Accepted formats are:** array of epoch timestamps for example `timespan[]=1498867200&timespan[]=1498953600` duration string for example `timespan[]=24:hours` or `timespan[]=7:days`
  - Allowed values: `60:minutes`, `6:hours`, `24:hours`, `3:days`, `7:days`, `30:days`
- `filterby[]` (string, optional) — Pass the dimensions and their corresponding values you want to filter the views by. For excluding the values in the filter we can pass "!" before the filter value. The list of filters can be obtained from list of dimensions endpoint. Example Values : [ browser_name:Chrome , os_name:macOS , !device_name:Galaxy ]

## Response

### 200

Get filter/ dimension value details by dimension name.

- `success` (boolean, optional) — Shows the request status. Returns true for success and false for failure.
- `metadata` (MetricsTimeseriesmetadataDetails, optional) — Retrieves breakdown values for a specified metric and timespan
- `data` (list of MetricsTimeseriesDataDetails, optional) — Displays the result of the request.
- `timespan` (list of integer, optional) — The timespan from and to details displayed in the form of unix epoch timestamps.

## Types

### MetricsTimeseriesmetadataDetails

Retrieves breakdown values for a specified metric and timespan

- `granularity` (string, optional) — the unit for aggregating the timeseries data.
- `aggregation` (string, optional) — defines the field or dimension on which the aggregation is to be applied.

### MetricsTimeseriesDataDetails

The metrics value at specific time intervals.

- `intervalTime` (datetime, optional) — The timestamp for the data point indicating when the metric value was recorded.
- `metricValue` (double, optional, nullable) — The value of the specified metric at the given interval.
- `numberOfViews` (integer, optional, nullable) — The total number of views recorded during that interval.

## Examples

**Response**

```json
{
  "success": true,
  "metadata": {
    "granularity": "day",
    "aggregation": "view_end"
  },
  "data": [
    {
      "intervalTime": "2023-12-04T14:00:00Z",
      "metricValue": 0.793110142151515,
      "numberOfViews": 143244
    }
  ],
  "timespan": [
    1610025789,
    1610025947
  ]
}
```

**SDK Code**

```python
import requests

url = "https://api.fastpix.com/v1/data/metrics/views/timeseries"

response = requests.get(url, auth=("<username>", "<password>"))

print(response.json())
```

```javascript
const url = 'https://api.fastpix.com/v1/data/metrics/views/timeseries';
const credentials = btoa("<username>:<password>");

const options = {method: 'GET', headers: {Authorization: `Basic ${credentials}`}};

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://api.fastpix.com/v1/data/metrics/views/timeseries"

	req, _ := http.NewRequest("GET", url, nil)

	req.SetBasicAuth("<username>", "<password>")

	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://api.fastpix.com/v1/data/metrics/views/timeseries")

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

request = Net::HTTP::Get.new(url)
request.basic_auth("<username>", "<password>")

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://api.fastpix.com/v1/data/metrics/views/timeseries")
  .basicAuth("<username>", "<password>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.fastpix.com/v1/data/metrics/views/timeseries', [
  'headers' => [
  ],
    'auth' => ['<username>', '<password>'],
]);

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

```csharp
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://api.fastpix.com/v1/data/metrics/views/timeseries");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.GET);

IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = ["Authorization": "Basic \(credentials)"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.fastpix.com/v1/data/metrics/views/timeseries")! 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()
```