# Server-Side-Integration | AudioDN Docs

> Nutzen Sie die API von AudioDN direkt von Ihrem Server aus für maximale Kontrolle über Uploads, Wiedergabe und Zugriffsverwaltung.

Source: https://audiodeliverynetwork.com/de/docs/integration/server-side/

---

# Server-Side-Integration

Nutzen Sie die ADN-API direkt, um Tracks zu speichern und die Wiedergabe zu verwalten. Bauen Sie vollständig individuelle Erlebnisse ohne ADN-Komponenten.

#### Ideal für

Individuelle Plattformen, Enterprise und Teams, die volle API-Kontrolle benötigen. Die Einrichtung dauert 1–2 Stunden.

## Tracks abspielen

Erstellen Sie Wiedergabesessions und rufen Sie Track-URLs von Ihrem Server ab.

Nutzen Sie die ADN-API direkt von Ihrem Server aus, um Wiedergabesessions zu erstellen und Track-URLs abzurufen. Bauen Sie vollständig individuelle Wiedergabeerlebnisse — ohne ADN-Webkomponenten.

### 1\. API-Key erstellen

Gehen Sie zu **Settings → API Keys** und erstellen Sie einen **API Access**\-Key.

### 2\. Wiedergabesession erstellen

```
const response = await fetch('https://api.audiodelivery.net/v1/play_session/collection', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    collection_id,
    variants: ['preview'],
    is_downloadable: false,
    expires_in: 3600 // session duration in seconds (default: 3600, min: 60, max: 86400)
  })
});

const { play_session_id, tracks } = await response.json();
```

Hier wenden Sie Ihre Geschäftslogik an — prüfen Sie Abonnements, verifizieren Sie Käufe oder setzen Sie Zugriffsregeln durch, bevor Sie die Session erstellen.

### 3\. Track-Daten abrufen

```
const { id: track_id } = tracks[0];

// No auth needed - the session ID acts as a bearer token
const response = await fetch(`https://api.audiodelivery.net/v1/play/${play_session_id}/${track_id}`);

const { variants } = await response.json();
const preview = variants.find(v => v.variant.index === 'preview');
console.log(`Play Audio File: ${preview.url}`);
```

### 4\. Individuelle Wiedergabe

Nutzen Sie die zurückgegebene URL in Ihrer eigenen Audio-Player-Implementierung. Funktioniert mit jeder Player-Bibliothek oder nativen mobilen Audio-API.

#### Wellenform-Daten

ADN erzeugt automatisch normalisierte RMS-Wellenform-Daten (320 Samples) für jeden Track. Das Feld `levels` in der Track-Antwort enthält die Daten — nutzen Sie sie, um Wellenformen in Ihrem eigenen Player darzustellen, oder erzeugen Sie individuelle Wellenformen über den Audio-Analyse-Variantentyp.

#### Coverbilder & Theme-Farben

ADN scannt jeden hochgeladenen Track auf eingebettetes Cover-Artwork und stellt es als `cover_image` in der Track-Antwort bereit (in den Größen icon/small/regular/large). Sie können ein Coverbild auch separat über die API hochladen. Wenn ein Coverbild vorhanden ist, extrahiert ADN eine Farbpalette und wählt eine primäre `player_color` — nutzen Sie diese, um Ihre Player-UI zu stylen. Zusätzlich enthalten Antworten `player_color_light` und `player_color_dark`, kontrastangepasste Varianten zum Darstellen der Farbe auf hellem bzw. dunklem Hintergrund. Das vollständige `theme`\-Array enthält alle extrahierten Farben mit Hex-Werten, Fläche, Helligkeit und Sättigungsdaten.

#### Öffentliche Tracks? Session überspringen

Für öffentlich verfügbare Tracks können Sie Delivery-URLs auf Ihrem eigenen Server mit einem URL-Signing-Key signieren und Wiedergabesessions vollständig überspringen — kein API-Roundtrip pro Hörer. Siehe den Schnelleinstieg [Signed Delivery](/docs/integration/signed-delivery) und die [Signing-Keys-API](/docs/api/signing-keys).

## Tracks hochladen

Nutzen Sie die ADN-API, um den gesamten Upload-Ablauf von Ihrem Server aus zu verwalten.

Nutzen Sie die ADN-API direkt von Ihrem Server aus, um Upload-Sessions zu erstellen, Tracks zu speichern und den gesamten Upload-Ablauf zu verwalten. Bauen Sie vollständig individuelle Upload-Oberflächen — ohne ADN-Webkomponenten.

### 1\. API-Key erstellen

Gehen Sie zu **Settings → API Keys** und erstellen Sie einen **API Access**\-Key.

### 2\. Upload-Session erstellen

```
const response = await fetch('https://api.audiodelivery.net/v1/upload_session', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    collection_id: 'COLLECTION-ID',
    expires_in: 3600 // session duration in seconds (default: 3600, min: 60, max: 86400)
    // Optional: add track: { file_name: 'song.wav' } to also create a track and get track_upload.upload_url
  })
});

const { upload_session } = await response.json();
```

### 3\. Tracks innerhalb der Session erstellen

```
const { id: upload_session_id } = upload_session;

// One request per file. No Authorization header needed here — the
// upload session ID authorizes track creation.
const response = await fetch(`https://api.audiodelivery.net/v1/upload/${upload_session_id}/track`, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ file_name: 'song.wav' })
});

const { track_id, track_upload } = await response.json();
const { method, upload_url, expires_at } = track_upload;
```

### 4\. Dateien hochladen

```
const file = document.querySelector('input[type="file"]').files[0];

await fetch(upload_url, {
  method,
  headers: { 'Content-Type': file.type },
  body: file
});
```

Wiederholen Sie Schritt 3 und 4 für jede Datei, die Sie der Session hinzufügen möchten — jeder Track benötigt seine eigene `POST /v1/upload/:upload_session_id/track`\-Anfrage und seine eigene signierte Upload-URL. Sie können auch ein verschachteltes `track`\-Objekt bei `POST /v1/upload_session` mitsenden, um den ersten Track direkt zu erstellen, und dann Schritt 3 für weitere Dateien nutzen.

### 5\. Warten, bis der Track bereit ist

Die Verarbeitung startet automatisch, sobald die Datei im Speicher angekommen ist. Warten Sie, bis der Status des Tracks `ready` ist, bevor Sie eine Wiedergabesession erstellen oder Delivery-URLs signieren — entweder durch Polling oder mit einem Webhook.

```
// Processing runs automatically after the upload. Poll the track until it is
// ready, or configure a webhook (below) to be notified instead of polling.
let track;
do {
  await new Promise((r) => setTimeout(r, 5000));
  const res = await fetch(`https://api.audiodelivery.net/v1/track/${track_id}`, {
    headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
  });
  ({ track } = await res.json());
} while (track.track_status_id !== 'ready');

// The track is now ready — create a play session or sign a delivery URL.
```

### 6\. Optional: Webhooks

Aktivieren Sie statt Polling einen Webhook unter **Settings → Webhook**, um benachrichtigt zu werden, wenn ein Track ein terminales Ergebnis erreicht (`ready`, `incomplete`, `error` oder `init_error`) und wenn sein vollständiger Dateisatz fertig ist. Siehe die Docs zum [Track-Processing-Webhook](/docs/webhooks/track-processing).

#### Coverbilder

ADN scannt hochgeladene Tracks automatisch auf eingebettetes Cover-Artwork. Sie können ein Coverbild auch separat über die Covers-API hochladen. Wenn ein Bild vorhanden ist, extrahiert ADN Farben (verfügbar als `theme`), die zum Stylen Ihrer Player-UI verwendet werden können.

## Keys generieren

Erzeugen Sie eingeschränkte Client-Side-Keys von Ihrem Server aus.

Sobald Sie einen **API Access**\-Key haben, können Sie `player`\- und `uploader`\-Keys programmatisch generieren — zum Beispiel einen Player-Key pro Kunde, beschränkt auf eine einzelne Sammlung. **Inline Share**\- und **URL Signing**\-Keys werden nicht über die API erstellt; provisionieren Sie sie über **Settings → API Keys** im Dashboard. Siehe die [API-Keys](/docs/api/api-keys)\-Referenz für alle Parameter.

### Eingeschränkten Key erstellen

```
// Use your API Access key to mint a scoped Client-Side Player key.
const response = await fetch('https://api.audiodelivery.net/v1/api_key', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_ACCESS_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    title: 'Customer Player Key',
    api_key_type_id: 'player',   // 'player' | 'uploader' (share & signing keys are dashboard-only)
    collection_id: 'COLLECTION_ID' // optional: limit the key to one collection
    // expires_at is optional via the API — omit for a key that never expires
  })
});

// The full key is returned once — store it securely, it cannot be retrieved again.
const { api_key } = await response.json();
```

Über die API ist `expires_at` für beide Key-Typen optional — lassen Sie es weg für einen Key, der zeitlich nie abläuft. API-Access-, Inline-Share- und URL-Signing-Keys müssen im Dashboard erstellt werden.