Se connecter à l’API REST NowMetrix

Connectez-vous à NowMetrix, ouvrez Paramètres → API, puis créez une clé API accompagnée d’un libellé pour l’intégration, par exemple Tableau de bord interne ou Google Sheets. Vous pouvez conserver jusqu’à 10 clés actives. Copiez immédiatement toute clé nouvelle ou renouvelée : sa valeur complète ne s’affiche qu’une seule fois.

NOWMETRIX_API_KEY=nm_YOUR_KEY

Renommer une clé ne modifie pas sa valeur. Le renouvellement ou la révocation d’une clé n’affecte que celle qui a été sélectionnée. Toutes les clés utilisent les autorisations de leur utilisateur NowMetrix et partagent la limite de requêtes de chaque tracker.

L’API REST est sans état : aucune requête de connexion distincte ni session persistante n’est nécessaire. Envoyez la clé API comme jeton Bearer avec chaque requête HTTPS.

GET https://api.nowmetrix.com/api/me
Authorization: Bearer nm_YOUR_KEY
Accept: application/json

• URL de base : https://api.nowmetrix.com
• Authentification : Authorization: Bearer nm_YOUR_KEY
• Test de connexion : GET /api/me ne nécessite aucun paramètre de tracker.
• Délais d’expiration : définissez un délai d’expiration fini pour la connexion et la réponse dans chaque client.

Utilisez cURL pour effectuer rapidement un test de connexion depuis un terminal.

API_KEY="nm_YOUR_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer ${API_KEY}" \
  --header "Accept: application/json" \
  "https://api.nowmetrix.com/api/me"

Une requête réussie renvoie le code HTTP 200 et la liste des trackers accessibles avec la clé API :

{
  "authenticated": true,
  "current_tracker": "TRACKER_ID",
  "trackers": [
    {
      "tracker": "TRACKER_ID",
      "host": "example-media.test"
    },
    {
      "tracker": "SECOND_TRACKER_ID",
      "host": "example-studio.test"
    }
  ]
}

Utilisez l’extension cURL de PHP et conservez la clé API dans une variable d’environnement.

<?php

$apiKey = getenv('NOWMETRIX_API_KEY');
if (!is_string($apiKey) || $apiKey === '') {
    throw new RuntimeException('NOWMETRIX_API_KEY is not set.');
}

$curl = curl_init('https://api.nowmetrix.com/api/me');
curl_setopt_array($curl, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . $apiKey,
        'Accept: application/json',
    ],
    CURLOPT_TIMEOUT => 10,
]);

$body = curl_exec($curl);
if ($body === false) {
    $error = curl_error($curl);
    curl_close($curl);
    throw new RuntimeException($error);
}

$status = curl_getinfo($curl, CURLINFO_RESPONSE_CODE);
curl_close($curl);

if ($status < 200 || $status >= 300) {
    throw new RuntimeException("NowMetrix API returned HTTP {$status}: {$body}");
}

$data = json_decode($body, true, 512, JSON_THROW_ON_ERROR);
print_r($data);

Utilisez l’API fetch intégrée côté serveur. N’exposez pas la clé API dans du code JavaScript exécuté dans le navigateur.

const apiKey = process.env.NOWMETRIX_API_KEY;
if (!apiKey) throw new Error('NOWMETRIX_API_KEY is not set.');

async function main() {
  const response = await fetch('https://api.nowmetrix.com/api/me', {
    headers: {
      Authorization: `Bearer ${apiKey}`,
      Accept: 'application/json',
    },
    signal: AbortSignal.timeout(10_000),
  });

  const body = await response.text();
  if (!response.ok) {
    throw new Error(`NowMetrix API returned HTTP ${response.status}: ${body}`);
  }

  console.log(JSON.parse(body));
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Le paquet requests fournit un client concis avec une gestion explicite des délais d’expiration et des statuts. Installez-le avec python -m pip install requests.

import os
import requests

api_key = os.environ["NOWMETRIX_API_KEY"]
response = requests.get(
    "https://api.nowmetrix.com/api/me",
    headers={
        "Authorization": f"Bearer {api_key}",
        "Accept": "application/json",
    },
    timeout=10,
)
response.raise_for_status()
print(response.json())

Le HttpClient standard de Java suffit pour effectuer la requête authentifiée.

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

public class NowMetrixExample {
    public static void main(String[] args) throws Exception {
        String apiKey = System.getenv("NOWMETRIX_API_KEY");
        if (apiKey == null || apiKey.isBlank()) {
            throw new IllegalStateException("NOWMETRIX_API_KEY is not set.");
        }

        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(10))
            .build();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.nowmetrix.com/api/me"))
            .timeout(Duration.ofSeconds(10))
            .header("Authorization", "Bearer " + apiKey)
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = client.send(
            request, HttpResponse.BodyHandlers.ofString()
        );
        if (response.statusCode() < 200 || response.statusCode() >= 300) {
            throw new IllegalStateException(
                "NowMetrix API returned HTTP " + response.statusCode() + ": " + response.body()
            );
        }

        System.out.println(response.body());
    }
}

Utilisez HttpClient avec un en-tête d’autorisation Bearer et un délai d’expiration défini au niveau de l’application.

using System.Net.Http.Headers;

var apiKey = Environment.GetEnvironmentVariable("NOWMETRIX_API_KEY")
    ?? throw new InvalidOperationException("NOWMETRIX_API_KEY is not set.");

using var client = new HttpClient
{
    BaseAddress = new Uri("https://api.nowmetrix.com"),
    Timeout = TimeSpan.FromSeconds(10),
};
client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", apiKey);
client.DefaultRequestHeaders.Accept.Add(
    new MediaTypeWithQualityHeaderValue("application/json")
);

using var response = await client.GetAsync("/api/me");
var body = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
    throw new HttpRequestException(
        $"NowMetrix API returned HTTP {(int)response.StatusCode}: {body}"
    );
}
Console.WriteLine(body);

Utilisez le client net/http standard et décodez la réponse JSON dans une structure générique ou dans vos propres types.

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"time"
)

func main() {
	apiKey := os.Getenv("NOWMETRIX_API_KEY")
	if apiKey == "" {
		panic("NOWMETRIX_API_KEY is not set")
	}

	request, err := http.NewRequest(http.MethodGet, "https://api.nowmetrix.com/api/me", nil)
	if err != nil {
		panic(err)
	}
	request.Header.Set("Authorization", "Bearer "+apiKey)
	request.Header.Set("Accept", "application/json")

	client := &http.Client{Timeout: 10 * time.Second}
	response, err := client.Do(request)
	if err != nil {
		panic(err)
	}
	defer response.Body.Close()

	if response.StatusCode < 200 || response.StatusCode >= 300 {
		panic("NowMetrix API returned " + response.Status)
	}

	var data map[string]any
	if err := json.NewDecoder(response.Body).Decode(&data); err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", data)
}

La bibliothèque standard de Ruby permet d’effectuer la requête sans paquet HTTP supplémentaire.

require 'json'
require 'net/http'

api_key = ENV.fetch('NOWMETRIX_API_KEY')
uri = URI('https://api.nowmetrix.com/api/me')
request = Net::HTTP::Get.new(uri)
request['Authorization'] = "Bearer #{api_key}"
request['Accept'] = 'application/json'

response = Net::HTTP.start(
  uri.hostname,
  uri.port,
  use_ssl: true,
  open_timeout: 10,
  read_timeout: 10
) { |http| http.request(request) }

unless response.is_a?(Net::HTTPSuccess)
  raise "NowMetrix API returned HTTP #{response.code}: #{response.body}"
end

puts JSON.pretty_generate(JSON.parse(response.body))

Vérifiez le statut HTTP avant de décoder une réponse de réussite. Les réponses d’erreur utilisent une structure JSON stable contenant un error.code lisible par machine.

• 401 missing_token : l’en-tête Authorization est absent.
• 401 invalid_token : la clé est invalide, révoquée ou a été remplacée.
• 403 site_not_authorized : la clé ne peut pas accéder au tracker demandé.
• 429 rate_limit_exceeded : attendez la durée indiquée par Retry-After avant de réessayer.
• 503 : en cas d’échec temporaire du serveur, réessayez avec un délai exponentiel plafonné.

{
  "error": {
    "code": "invalid_token",
    "message": "Bearer token is invalid or revoked."
  }
}

Lisez la valeur current_tracker ou trackers[].tracker dans /api/me, puis transmettez l’identifiant de ce tracker comme paramètre de requête site.

GET https://api.nowmetrix.com/v1/realtime?site=TRACKER_ID
Authorization: Bearer nm_YOUR_KEY
Accept: application/json