API Keys

Create new API keys server-to-server using an existing API Access key. This lets you provision Client-Side Player and Client-Side Upload keys on demand — for example, minting a scoped player key per customer.

Inline Share & URL Signing keys are dashboard-only

Inline Share (see Inline Share) and URL Signing (see Signing Keys) keys are documented here for reference, but they cannot be created or managed through the API. They must be created from Settings → API Keys in the AudioDN dashboard, because they provision edge configuration (signing rules) that the API does not manage.

API Access keys are created in the dashboard

You must first create an API Access key from Settings → API Keys in the AudioDN dashboard. That key authenticates this endpoint. API Access keys themselves cannot be created via the API.

Creatable Key Types

player — Client-Side Player key for playback
uploader — Client-Side Upload key for uploads

The api (API Access), share (Inline Share), and signing (URL Signing) types cannot be created here — they are managed only from the dashboard Settings → API Keys page.

Expiry & Scope

Via the API, expires_at is optional for both key types — omit it to create a key that never expires by time. You can optionally limit a key to a specific collection_id (and further to a track_id). If your API Access key is itself scoped to a collection, the new key cannot be scoped outside it.

Downloads: a player key can optionally permit downloads. This is set from the dashboard when creating the key (the Allow downloads toggle) and is not configurable through this API endpoint. The key’s download permission is authoritative: the player downloadable attribute only requests downloads, and a play session is downloadable only when the key allows it and the request opts in.

POST /v1/api_key

Creates a new player or uploader API key

Parameters

Name	Type	Required	Description
`title`	string	Required	Name of the API key
`api_key_type_id`	string	Required	One of 'player' or 'uploader'. Share and signing keys are dashboard-only.
`collection_id`	uuid	Optional	Limit the key to a specific collection
`track_id`	uuid	Optional	Limit the key to a specific track (requires collection_id)
`creator_id`	uuid	Optional	Limit the key to a specific creator
`variants`	array of strings	Optional	Optional. Limit a player key to specific variants.
`expires_at`	string	Optional	ISO 8601 expiration date/time. Optional; omit for a key that never expires by time.

Example Request

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>;
}

Response

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

Shown once

The full api_key is returned only in this response and is never stored in plaintext. Save it securely — it cannot be retrieved again.