> 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.

# Gecomponeerde muziek met een gedetailleerd antwoord streamen

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

Stream een nummer en de gedetailleerde metadata ervan met 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) — Uitvoerformaat van de gegenereerde audio. Opgegeven als codec_sample_rate_bitrate. Gebruik "auto" (de standaardwaarde) om de API het beste formaat voor het geselecteerde model te laten kiezen: mp3_44100_128 voor v1-modellen en mp3_48000_192 voor v2-modellen.
  - 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`

### Body (application/json)

This endpoint expects a Body_Stream_composed_music_with_a_detailed_response_v1_music_detailed_stream_post.

- `prompt` (string, optional, nullable) — Een eenvoudige tekstprompt om een nummer mee te genereren. Kan niet worden gebruikt in combinatie met `composition_plan`.
- `composition_plan` (BodyStreamComposedMusicWithADetailedResponseV1MusicDetailedStreamPostCompositionPlan, optional, nullable) — Een gedetailleerd compositieplan om de muziekgeneratie te sturen. Kan niet samen met `prompt` worden gebruikt.
- `music_length_ms` (integer, optional, nullable) — De lengte van het te genereren nummer in milliseconden. Wordt alleen gebruikt in combinatie met `prompt`. Moet tussen 3000 ms en 600000 ms liggen. Optioneel: als je geen waarde opgeeft, kiest het model een lengte op basis van de prompt.
- `model_id` (enum, optional, default: music_v1) — Het model dat voor de generatie moet worden gebruikt.
  - Allowed values: `music_v1`, `music_v2`, `music_v2_5`
- `seed` (integer, optional, nullable) — Willekeurige seed om het muziekgeneratieproces te initialiseren. Dezelfde seed met dezelfde parameters kan helpen om consistentere resultaten te behalen, maar exacte reproduceerbaarheid is niet gegarandeerd en uitvoer kan veranderen na systeemupdates. Kan niet samen met prompt worden gebruikt.
- `force_instrumental` (boolean, optional, default: false) — Als true, is het gegarandeerd dat het gegenereerde nummer instrumentaal is. Als false, kan het nummer afhankelijk van de `prompt` al dan niet instrumentaal zijn. Kan alleen met `prompt` worden gebruikt.
- `finetune_id` (string, optional, nullable) — De ID van de finetune die voor de generatie moet worden gebruikt
- `store_for_inpainting` (boolean, optional, default: false) — Of het gegenereerde nummer voor inpainting moet worden opgeslagen.
- `with_timestamps` (boolean, optional, default: false) — Of de tijdstempels van de woorden in het gegenereerde nummer moeten worden teruggestuurd.
- `with_waveform_visual` (boolean, optional, default: false) — Of de visuele golfvorm van het gegenereerde nummer moet worden teruggestuurd.

## Response

### 200

Server-Sent Events voor het compositieplan, songmetadata, audiochunks met optionele woordtijdstempels en visuele golfvorm, en voltooiing.

- Streaming response of `string`.

## Errors

### 422 Unprocessable Entity Error

Validatiefout

- `detail` (list of ValidationError, optional)

## Types

### BodyStreamComposedMusicWithADetailedResponseV1MusicDetailedStreamPostCompositionPlan

Een gedetailleerd compositieplan om de muziekgeneratie te sturen. Kan niet samen met `prompt` worden gebruikt.

### ValidationError

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

### MusicPrompt

Compositieplan voor het model `music_v1`. Als je dit veld met een ander model gebruikt, resulteert dat in een fout.

- `positive_global_styles` (list of string, required) — De stijlen en muzikale aanwijzingen die in het hele nummer aanwezig moeten zijn. Gebruik Engels voor het beste resultaat.
- `negative_global_styles` (list of string, required) — De stijlen en muzikale aanwijzingen die niet in het hele nummer aanwezig mogen zijn. Gebruik Engels voor het beste resultaat.
- `sections` (list of SongSection, required) — De secties van het nummer.

### CompositionPlan

Compositieplan voor de modellen `music_v2` en `music_v2_5`. Als je dit veld met een ander model gebruikt, resulteert dat in een fout.

- `chunks` (list of CompositionPlanChunksItems, required) — De chunks waaruit de generatie bestaat.

### ValidationErrorLocItems

### SongSection

- `section_name` (string, required) — De naam van de sectie. Moet uit 1 tot 100 tekens bestaan.
- `positive_local_styles` (list of string, required) — De stijlen en muzikale aanwijzingen die in deze sectie aanwezig moeten zijn. Gebruik Engels voor het beste resultaat.
- `negative_local_styles` (list of string, required) — De stijlen en muzikale aanwijzingen die niet in deze sectie aanwezig mogen zijn. Gebruik Engels voor het beste resultaat.
- `duration_ms` (integer, required) — De duur van de sectie in milliseconden. Moet tussen 3000 ms en 120000 ms liggen.
- `lines` (list of string, required) — De songtekst van de sectie. Maximaal 30 regels per sectie en maximaal 200 tekens per regel.
- `source_from` (SectionSource, optional, nullable) — Optionele bron waaruit de sectie wordt geëxtraheerd. Gebruikt voor inpainting.

### CompositionPlanChunksItems

### SectionSource

- `song_id` (string, required) — De ID van het nummer waaruit de sectie afkomstig is. Je vindt de nummer-ID in de responseheaders wanneer je een nummer genereert.
- `range` (TimeRange, required) — Het bereik dat uit het bronnummers moet worden geëxtraheerd.
- `negative_ranges` (list of TimeRange, optional) — De bereiken die van het 'range' moeten worden uitgesloten.

### GenerationChunk-Input

- `text` (string, required) — De tekstconfiguratie die voor dit fragment moet worden gegenereerd. Kan aan het begin een optionele sectienaam tussen vierkante haken bevatten, bijvoorbeeld \[Verse 1], songtekstregels en inline-instructies tussen accolades, bijvoorbeeld \{scratching}. Sectienamen moeten tussen 1 en 100 tekens lang zijn. Er zijn maximaal 30 regels toegestaan, elk met maximaal 200 tekens.
- `duration_ms` (integer, required) — De duur van het chunk in milliseconden. Moet tussen 3000 ms en 120000 ms liggen.
- `positive_styles` (list of string, required) — De stijlen en muzikale aanwijzingen die in dit segment aanwezig moeten zijn. Gebruik Engels voor de beste resultaten. De stijlen voor het eerste segment zijn het belangrijkst, omdat ze de algemene toon en het genre bepalen. Stijlen voor volgende segmenten kunnen nuance, ontwikkeling of nadruk toevoegen, of de richting van het nummer veranderen. Streef naar ten minste 6-7 stijlen in de eerste segmenten, totdat de richting is bepaald. Algemene stijlen zoals 'great production quality' zijn goede standaardstijlen om aan de lijst toe te voegen.
- `negative_styles` (list of string, optional) — De stijlen en muzikale aanwijzingen die niet in dit segment aanwezig mogen zijn. Gebruik Engels voor de beste resultaten. Leeg laten is een goede standaardinstelling; gebruik dit veld alleen als je een bepaalde stijl of richting expliciet wilt vermijden.
- `context_adherence` (enum, optional, default: high) — In hoeverre het model zich aan de context van de omliggende chunks houdt. Bij lage naleving kan het model van de context afwijken en creatiever zijn. Bij hoge naleving is het model consistenter met de context.
  - Allowed values: `low`, `medium`, `high`
- `conditioning_ref` (AudioRefChunk, optional, nullable) — De audioverwijzing waarop de generatie wordt gebaseerd. Het eerste chunk is het belangrijkst, omdat dit de generatie van alle volgende chunks beïnvloedt. Als je de hele song hierop wilt baseren, begin dan bij het eerste chunk.
- `condition_strength` (enum, optional, nullable) — Hoe sterk het model zich aan de conditioneringsreferentie houdt. Een lage sterkte betekent dat het model creatiever is en van de referentie afwijkt. Een hoge sterkte betekent dat het model consistenter met de referentie is.
  - Allowed values: `low`, `medium`, `high`, `xhigh`

### AudioRefChunk

- `song_id` (string, required) — De ID van het nummer waaruit het fragment afkomstig is. Je vindt de nummer-ID in de responseheaders wanneer je een nummer genereert.
- `range` (TimeRange, required) — Het tijdbereik dat uit het nummer moet worden geëxtraheerd.

### 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()
```