Export Device Report

import requests

url = "https://api.addressable.tv/campaigns/exportClientDeviceReport"
headers = {
    "x-api-key": "YOUR_API_KEY",
    "client": "YOUR_CLIENT_KEY"
}

# Optional: use broadcast month aggregation
params = {"type": "broadcast"}

response = requests.get(url, headers=headers, params=params)
data = response.json()
print(data)

const fetch = require('node-fetch');

// Optional: use broadcast month aggregation
const params = new URLSearchParams({ type: 'broadcast' });
const url = `https://api.addressable.tv/campaigns/exportClientDeviceReport?${params}`;
const headers = {
  'x-api-key': 'YOUR_API_KEY',
  client: 'YOUR_CLIENT_KEY',
};

fetch(url, { headers })
  .then((response) => response.json())
  .then((data) => console.log(data))
  .catch((error) => console.error(error));

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class FetchData {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.addressable.tv/campaigns/exportClientDeviceReport"))
            .header("x-api-key", "YOUR_API_KEY")
            .header("client", "YOUR_CLIENT_KEY")
            .build();

        client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
            .thenApply(HttpResponse::body)
            .thenAccept(System.out::println)
            .join();
    }
}

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    url := "https://api.addressable.tv/campaigns/exportClientDeviceReport"
    client := &http.Client{}
    req, _ := http.NewRequest("GET", url, nil)

    req.Header.Add("x-api-key", "YOUR_API_KEY")
    req.Header.Add("client", "YOUR_CLIENT_KEY")

    resp, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        var request = new HttpRequestMessage
        {
            Method = HttpMethod.Get,
            RequestUri = new Uri("https://api.addressable.tv/campaigns/exportClientDeviceReport")
        };

        request.Headers.Add("x-api-key", "YOUR_API_KEY");
        request.Headers.Add("client", "YOUR_CLIENT_KEY");

        var response = await client.SendAsync(request);
        response.EnsureSuccessStatusCode();
        var data = await response.Content.ReadAsStringAsync();
        Console.WriteLine(data);
    }
}

#include <curl/curl.h>
#include <iostream>
#include <string>

static size_t WriteCallback(void *contents, size_t size, size_t nmemb, void *userp)
{
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}

int main()
{
    CURL *curl;
    CURLcode res;
    std::string readBuffer;

    curl = curl_easy_init();
    if(curl) {
        struct curl_slist *headers = NULL;
        headers = curl_slist_append(headers, "x-api-key: YOUR_API_KEY");
        headers = curl_slist_append(headers, "client: YOUR_CLIENT_KEY");

        curl_easy_setopt(curl, CURLOPT_URL, "https://api.addressable.tv/campaigns/exportClientDeviceReport");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

        res = curl_easy_perform(curl);
        if(res != CURLE_OK)
            std::cout << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;

        curl_easy_cleanup(curl);
        curl_slist_free_all(headers);
    }

    std::cout << readBuffer << std::endl;
    return 0;
}