# Clés API | Docs AudioDN

> Générez des clés Client-Side Player et Client-Side Upload de façon programmatique depuis votre serveur.

Source: https://audiodeliverynetwork.com/fr/docs/api/api-keys/

---

# 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](/docs/api/share)) et **URL Signing** (voir [Signing Keys](/docs/api/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](https://account.audiodeliverynetwork.com), 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](https://account.audiodeliverynetwork.com). 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.