Clés API

Créez de nouvelles clés API de serveur à serveur à l’aide d’une clé API Access existante. Cela vous permet de provisionner des clés Client-Side Player et Client-Side Upload à la demande — par exemple, en générant une clé lecteur limitée par client.

Les clés Inline Share et URL Signing sont réservées au tableau de bord

Les clés Inline Share (voir Inline Share) et URL Signing (voir Signing Keys) sont documentées ici pour référence, mais elles ne peuvent pas être créées ni gérées via l’API. Elles doivent être créées depuis Settings → API Keys dans le tableau de bord AudioDN, car elles provisionnent une configuration en périphérie (règles de signature) que l’API ne gère pas.

Les clés API Access sont créées dans le tableau de bord

Vous devez d’abord créer une clé API Access depuis Settings → API Keys dans le tableau de bord AudioDN. Cette clé authentifie ce point de terminaison. Les clés API Access elles-mêmes ne peuvent pas être créées via l’API.

Types de clés créables

player — Clé Client-Side Player pour la lecture
uploader — Clé Client-Side Upload pour les envois

Les types api (API Access), share (Inline Share) et signing (URL Signing) ne peuvent pas être créés ici — ils sont gérés uniquement depuis la page Settings → API Keys du tableau de bord.

Expiration et portée

Via l’API, expires_at est optionnel pour les deux types de clés — omettez-le pour créer une clé qui n’expire jamais dans le temps. Vous pouvez optionnellement limiter une clé à un collection_id spécifique (et davantage à un track_id). Si votre clé API Access est elle-même limitée à une collection, la nouvelle clé ne peut pas être limitée en dehors de celle-ci.

Téléchargements : une clé lecteur peut optionnellement autoriser les téléchargements. Cela se configure depuis le tableau de bord lors de la création de la clé (le bascule Allow downloads) et n’est pas configurable via ce point de terminaison API. La permission de téléchargement de la clé fait autorité : l’attribut downloadable du lecteur ne fait que demander les téléchargements, et une session de lecture n’est téléchargeable que lorsque la clé l’autorise et que la requête l’active.

POST /v1/api_key

Crée une nouvelle clé API lecteur ou envoyeur

Paramètres

Nom	Type	Obligatoire	Description
`title`	string	Obligatoire	Nom de la clé API
`api_key_type_id`	string	Obligatoire	L'une des valeurs 'player' ou 'uploader'. Les clés share et signing sont réservées au tableau de bord.
`collection_id`	uuid	Facultatif	Limiter la clé à une collection spécifique
`track_id`	uuid	Facultatif	Limiter la clé à une piste spécifique (nécessite collection_id)
`creator_id`	uuid	Facultatif	Limiter la clé à un créateur spécifique
`variants`	array of strings	Facultatif	Optionnel. Limiter une clé lecteur à des variantes spécifiques.
`expires_at`	string	Facultatif	Date/heure d'expiration ISO 8601. Optionnel ; omettre pour une clé qui n'expire jamais dans le temps.

Exemple de requête

curl -X POST "https://api.audiodelivery.net/v1/api_key" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "title": "Customer Player Key",
  "api_key_type_id": "player",
  "collection_id": "COLLECTION_ID"
}'

const payload = {
  "title": "Customer Player Key",
  "api_key_type_id": "player",
  "collection_id": "COLLECTION_ID"
};

const response = await fetch('https://api.audiodelivery.net/v1/api_key', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify(payload)
});

const data = await response.json();

import Foundation

func performRequest() async throws {
    var request = URLRequest(url: URL(string: "https://api.audiodelivery.net/v1/api_key")!)
    request.httpMethod = "POST"
    request.setValue("Bearer YOUR_API_KEY", forHTTPHeaderField: "Authorization")
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
    let bodyJSON = """
{
  "title": "Customer Player Key",
  "api_key_type_id": "player",
  "collection_id": "COLLECTION_ID"
}
"""
    request.httpBody = bodyJSON.data(using: .utf8)
    let (data, _) = try await URLSession.shared.data(for: request)
    let json = try JSONSerialization.jsonObject(with: data) as! [String: Any]
    // use json
}

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody

val client = OkHttpClient()

suspend fun performRequest(): String = withContext(Dispatchers.IO) {
    val body = """{
  "title": "Customer Player Key",
  "api_key_type_id": "player",
  "collection_id": "COLLECTION_ID"
}""".toRequestBody("application/json".toMediaType())
    val request = Request.Builder()
        .url("https://api.audiodelivery.net/v1/api_key")
        .post(body)
        .addHeader("Authorization", "Bearer YOUR_API_KEY")
        .addHeader("Content-Type", "application/json")
        .build()
    val response = client.newCall(request).execute()
    response.body?.string() ?: error("Empty response body")
}

import 'dart:convert';
import 'package:http/http.dart' as http;

Future<Map<String, dynamic>> performRequest() async {
  final response = await http.post(
    Uri.parse("https://api.audiodelivery.net/v1/api_key"),
    headers: {
      "Authorization": "Bearer YOUR_API_KEY",
      "Content-Type": "application/json",
    },
    body: jsonEncode({
  "title": "Customer Player Key",
  "api_key_type_id": "player",
  "collection_id": "COLLECTION_ID"
}),
  );
  if (response.statusCode < 200 || response.statusCode >= 300) {
    throw Exception('Request failed: ${response.statusCode}');
  }
  return jsonDecode(response.body) as Map<String, dynamic>;
}

Réponse

{
"ok": true,
"api_request_id": "uuid",
"api_key": "string"
}

Affichée une seule fois

La clé api_key complète n’est renvoyée que dans cette réponse et n’est jamais stockée en clair. Conservez-la en sécurité — elle ne pourra pas être récupérée à nouveau.