> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt.

# Komponierte Musik mit detaillierter Antwort streamen

POST https://api.elevenlabs.io/v1/music/detailed/stream
Content-Type: application/json

Streamen Sie einen Song und seine detaillierten Metadaten über Server-Sent Events (SSE).

Reference: https://elevenlabs.io/docs/api-reference/music/compose-detailed-stream

## Servers

- `https://api.elevenlabs.io` (Production, default)
- `https://api.us.elevenlabs.io` (Production US)
- `https://api.eu.residency.elevenlabs.io` (Production EU)
- `https://api.in.residency.elevenlabs.io` (Production India)
- `https://api.sg.residency.elevenlabs.io` (Production Singapore)

## Request

### Query parameters

- `output_format` (enum, optional, default: auto) — Ausgabeformat des generierten Audios. Formatiert als codec_sample_rate_bitrate. Verwenden Sie „auto“ (Standard), damit die API das beste Format für das ausgewählte Modell wählt: mp3_44100_128 für v1-Modelle und mp3_48000_192 für v2-Modelle.
  - Allowed values: `auto`, `mp3_48000_128`, `mp3_48000_192`, `mp3_48000_240`, `mp3_48000_320`, `mp3_22050_32`, `mp3_24000_48`, `mp3_44100_32`, `mp3_44100_64`, `mp3_44100_96`, `mp3_44100_128`, `mp3_44100_192`, `pcm_8000`, `pcm_16000`, `pcm_22050`, `pcm_24000`, `pcm_32000`, `pcm_44100`, `pcm_48000`, `ulaw_8000`, `alaw_8000`, `opus_48000_32`, `opus_48000_64`, `opus_48000_96`, `opus_48000_128`, `opus_48000_192`
- `enable_logging` (boolean, optional, default: true) — Wenn enable_logging auf false gesetzt ist, wird für die Anfrage der Modus ohne Datenspeicherung verwendet. Dieser Modus steht nur Enterprise-Kunden zur Verfügung.

### Body (application/json)

This endpoint expects a Body_Stream_composed_music_with_a_detailed_response_v1_music_detailed_stream_post.

- `prompt` (string, optional, nullable) — Ein einfacher Text-Prompt, aus dem ein Song generiert wird. Kann nicht zusammen mit `composition_plan` verwendet werden.
- `composition_plan` (BodyStreamComposedMusicWithADetailedResponseV1MusicDetailedStreamPostCompositionPlan, optional, nullable) — Ein detaillierter Kompositionsplan zur Steuerung der Musikgenerierung. Kann nicht zusammen mit `prompt` verwendet werden.
- `music_length_ms` (integer, optional, nullable) — Die Länge des zu generierenden Songs in Millisekunden. Wird nur zusammen mit `prompt` verwendet. Muss zwischen 3000 ms und 600000 ms liegen. Optional – wenn nicht angegeben, wählt das Modell anhand des Prompts eine Länge.
- `model_id` (enum, optional, default: music_v1) — Das für die Generierung zu verwendende Modell.
  - Allowed values: `music_v1`, `music_v2`, `music_v2_5`
- `seed` (integer, optional, nullable) — Zufalls-Seed zur Initialisierung der Musikgenerierung. Derselbe Seed mit denselben Parametern kann zu konsistenteren Ergebnissen führen, eine exakte Reproduzierbarkeit ist jedoch nicht garantiert und Ausgaben können sich durch Systemupdates ändern. Kann nicht zusammen mit prompt verwendet werden.
- `force_instrumental` (boolean, optional, default: false) — Wenn true, wird garantiert, dass der generierte Song instrumental ist. Wenn false, kann der Song abhängig von `prompt` instrumental sein oder nicht. Kann nur mit `prompt` verwendet werden.
- `finetune_id` (string, optional, nullable) — Die ID des für die Generierung zu verwendenden Finetunes
- `store_for_inpainting` (boolean, optional, default: false) — Ob der generierte Song für Inpainting gespeichert werden soll.
- `with_timestamps` (boolean, optional, default: false) — Ob die Zeitstempel der Wörter im generierten Song zurückgegeben werden sollen.
- `with_waveform_visual` (boolean, optional, default: false) — Ob die visuelle Wellenform des generierten Songs zurückgegeben werden soll.

## Response

### 200

Server-Sent Events für Kompositionsplan, Song-Metadaten, Audio-Chunks mit optionalen Wort-Zeitstempeln und visueller Wellenform sowie Abschluss.

- Streaming response of `string`.

## Errors

### 422 Unprocessable Entity Error

Validierungsfehler

- `detail` (list of ValidationError, optional)

## Types

### BodyStreamComposedMusicWithADetailedResponseV1MusicDetailedStreamPostCompositionPlan

Ein detaillierter Kompositionsplan zur Steuerung der Musikgenerierung. Kann nicht zusammen mit `prompt` verwendet werden.

### ValidationError

- `loc` (list of ValidationErrorLocItems, required)
- `msg` (string, required)
- `type` (string, required)

### MusicPrompt

Kompositionsplan für das Modell `music_v1`. Die Verwendung dieses Felds mit einem anderen Modell führt zu einem Fehler.

- `positive_global_styles` (list of string, required) — Die Stile und musikalischen Vorgaben, die im gesamten Song vorkommen sollen. Verwenden Sie für beste Ergebnisse Englisch.
- `negative_global_styles` (list of string, required) — Die Stile und musikalischen Vorgaben, die im gesamten Song nicht vorkommen sollen. Verwenden Sie für beste Ergebnisse Englisch.
- `sections` (list of SongSection, required) — Die Abschnitte des Songs.

### CompositionPlan

Kompositionsplan für die Modelle `music_v2` und `music_v2_5`. Die Verwendung dieses Felds mit einem anderen Modell führt zu einem Fehler.

- `chunks` (list of CompositionPlanChunksItems, required) — Die Chunks, aus denen die Generierung besteht.

### ValidationErrorLocItems

### SongSection

- `section_name` (string, required) — Der Name des Abschnitts. Muss zwischen 1 und 100 Zeichen lang sein.
- `positive_local_styles` (list of string, required) — Die Stile und musikalischen Vorgaben, die in diesem Abschnitt vorkommen sollen. Verwenden Sie für beste Ergebnisse Englisch.
- `negative_local_styles` (list of string, required) — Die Stile und musikalischen Vorgaben, die in diesem Abschnitt nicht vorkommen sollen. Verwenden Sie für beste Ergebnisse Englisch.
- `duration_ms` (integer, required) — Die Dauer des Abschnitts in Millisekunden. Muss zwischen 3000 ms und 120000 ms liegen.
- `lines` (list of string, required) — Der Liedtext des Abschnitts. Maximal 30 Zeilen pro Abschnitt und 200 Zeichen pro Zeile.
- `source_from` (SectionSource, optional, nullable) — Optionale Quelle, aus der der Abschnitt extrahiert wird. Wird für Inpainting verwendet.

### CompositionPlanChunksItems

### SectionSource

- `song_id` (string, required) — Die ID des Songs, aus dem der Teil stammen soll. Sie finden die Song-ID in den Antwort-Headern, wenn Sie einen Song generieren.
- `range` (TimeRange, required) — Der aus dem Quellsong zu extrahierende Bereich.
- `negative_ranges` (list of TimeRange, optional) — Die Bereiche, die aus 'range' ausgeschlossen werden sollen.

### GenerationChunk-Input

- `text` (string, required) — Die für diesen Abschnitt zu generierende Textkonfiguration. Sie kann am Anfang einen optionalen Abschnittsnamen in eckigen Klammern enthalten, z. B. \[Verse 1], Liedtextzeilen und Inline-Anweisungen in geschweiften Klammern, z. B. \{scratching}. Abschnittsnamen müssen zwischen 1 und 100 Zeichen lang sein. Es sind maximal 30 Zeilen mit jeweils höchstens 200 Zeichen erlaubt.
- `duration_ms` (integer, required) — Die Dauer des Chunks in Millisekunden. Muss zwischen 3000 ms und 120000 ms liegen.
- `positive_styles` (list of string, required) — Die Stile und musikalischen Vorgaben, die in diesem Abschnitt vorkommen sollen. Verwenden Sie für beste Ergebnisse Englisch. Die Stile des ersten Abschnitts sind am wichtigsten, da sie den allgemeinen Ton und das Genre festlegen. Stile für nachfolgende Abschnitte können Nuancen, Entwicklungen oder Akzente hinzufügen oder die Richtung des Songs ändern. Verwenden Sie in frühen Abschnitten mindestens 6–7 Stile, bis die Richtung festgelegt ist. Allgemeine Stile wie „great production quality“ eignen sich gut als Standard, um sie der Liste hinzuzufügen.
- `negative_styles` (list of string, optional) — Die Stile und musikalischen Vorgaben, die in diesem Abschnitt nicht vorkommen sollen. Verwenden Sie für beste Ergebnisse Englisch. Standardmäßig sollten Sie das Feld leer lassen. Verwenden Sie es nur, wenn Sie einen bestimmten Stil oder eine Richtung ausdrücklich vermeiden möchten.
- `context_adherence` (enum, optional, default: high) — Wie stark das Modell dem Kontext der umgebenden Chunks folgt. Geringe Bindung bedeutet, dass das Modell vom Kontext abweichen und kreativer sein kann. Hohe Bindung bedeutet, dass das Modell konsistenter mit dem Kontext ist.
  - Allowed values: `low`, `medium`, `high`
- `conditioning_ref` (AudioRefChunk, optional, nullable) — Die Audioreferenz, auf der die Generierung basiert. Der erste Chunk ist am wichtigsten, da er die Generierung aller nachfolgenden Chunks beeinflusst. Wenn die Konditionierung auf den gesamten Song angewendet werden soll, beginnen Sie mit dem ersten Chunk.
- `condition_strength` (enum, optional, nullable) — Wie stark das Modell der konditionierenden Referenz folgt. Geringe Stärke bedeutet, dass das Modell kreativer ist und von der Referenz abweicht. Hohe Stärke bedeutet, dass das Modell konsistenter mit der Referenz ist.
  - Allowed values: `low`, `medium`, `high`, `xhigh`

### AudioRefChunk

- `song_id` (string, required) — Die ID des Songs, aus dem der Abschnitt stammen soll. Sie finden die Song-ID in den Antwort-Headern, wenn Sie einen Song generieren.
- `range` (TimeRange, required) — Der aus dem Song zu extrahierende Zeitbereich.

### TimeRange

- `start_ms` (integer, required)
- `end_ms` (integer, required)

## Examples

**Request**

```json
{}
```

**Response**

```json
[
  "string"
]
```

**SDK Code**

```python
import requests

url = "https://api.elevenlabs.io/v1/music/detailed/stream"

payload = {}
headers = {"Content-Type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.elevenlabs.io/v1/music/detailed/stream';
const options = {method: 'POST', headers: {'Content-Type': 'application/json'}, body: '{}'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.elevenlabs.io/v1/music/detailed/stream"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.elevenlabs.io/v1/music/detailed/stream")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request.body = "{}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.elevenlabs.io/v1/music/detailed/stream")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.elevenlabs.io/v1/music/detailed/stream', [
  'body' => '{}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.elevenlabs.io/v1/music/detailed/stream");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.elevenlabs.io/v1/music/detailed/stream")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```