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

# Strömma komponerad musik med ett detaljerat svar

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

Streama en låt och dess detaljerade metadata med 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) — Utdataformat för det genererade ljudet. Formateras som codec_sample_rate_bitrate. Använd "auto" (standardvärdet) för att låta API:et välja det bästa formatet för den valda modellen: mp3_44100_128 för v1-modeller och mp3_48000_192 för v2-modeller.
  - 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) — En enkel textprompt att generera en låt från. Kan inte användas tillsammans med `composition_plan`.
- `composition_plan` (BodyStreamComposedMusicWithADetailedResponseV1MusicDetailedStreamPostCompositionPlan, optional, nullable) — En detaljerad kompositionsplan som styr musikgenereringen. Kan inte användas tillsammans med `prompt`.
- `music_length_ms` (integer, optional, nullable) — Längden på låten som ska genereras, i millisekunder. Används endast tillsammans med `prompt`. Måste vara mellan 3000 ms och 600000 ms. Valfritt – om inget anges väljer modellen en längd utifrån prompten.
- `model_id` (enum, optional, default: music_v1) — Modellen som ska användas för genereringen.
  - Allowed values: `music_v1`, `music_v2`, `music_v2_5`
- `seed` (integer, optional, nullable) — Slumpmässigt seed för att initiera musikgenereringsprocessen. Att ange samma seed med samma parametrar kan ge mer konsekventa resultat, men exakt reproducerbarhet garanteras inte och utdata kan ändras mellan systemuppdateringar. Kan inte användas tillsammans med prompt.
- `force_instrumental` (boolean, optional, default: false) — Om värdet är true garanteras att den genererade låten är instrumental. Om värdet är false kan låten vara instrumental eller inte, beroende på `prompt`. Kan endast användas med `prompt`.
- `finetune_id` (string, optional, nullable) — ID:t för den Finetune som ska användas för genereringen
- `store_for_inpainting` (boolean, optional, default: false) — Om den genererade låten ska lagras för inpainting.
- `with_timestamps` (boolean, optional, default: false) — Om tidsstämplarna för orden i den genererade låten ska returneras.
- `with_waveform_visual` (boolean, optional, default: false) — Om den visuella vågformen för den genererade låten ska returneras.

## Response

### 200

Server-Sent Events för kompositionsplan, låtmetadata, ljudsegment med valfria ordtidsstämplar och visuell vågform samt slutförande.

- Streaming response of `string`.

## Errors

### 422 Unprocessable Entity Error

Valideringsfel

- `detail` (list of ValidationError, optional)

## Types

### BodyStreamComposedMusicWithADetailedResponseV1MusicDetailedStreamPostCompositionPlan

En detaljerad kompositionsplan som styr musikgenereringen. Kan inte användas tillsammans med `prompt`.

### ValidationError

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

### MusicPrompt

Kompositionsplan för modellen `music_v1`. Om detta fält används med någon annan modell uppstår ett fel.

- `positive_global_styles` (list of string, required) — Stilarna och musikaliska riktningarna som ska finnas i hela låten. Använd engelska för bäst resultat.
- `negative_global_styles` (list of string, required) — Stilarna och musikaliska riktningarna som inte ska finnas i hela låten. Använd engelska för bäst resultat.
- `sections` (list of SongSection, required) — Låtens avsnitt.

### CompositionPlan

Kompositionsplan för modellerna `music_v2` och `music_v2_5`. Om detta fält används med någon annan modell uppstår ett fel.

- `chunks` (list of CompositionPlanChunksItems, required) — Segmenten som utgör genereringen.

### ValidationErrorLocItems

### SongSection

- `section_name` (string, required) — Namnet på avsnittet. Måste vara mellan 1 och 100 tecken.
- `positive_local_styles` (list of string, required) — Stilarna och musikaliska riktningarna som ska finnas i det här avsnittet. Använd engelska för bäst resultat.
- `negative_local_styles` (list of string, required) — Stilarna och musikaliska riktningarna som inte ska finnas i det här avsnittet. Använd engelska för bäst resultat.
- `duration_ms` (integer, required) — Avsnittets längd i millisekunder. Måste vara mellan 3000 ms och 120000 ms.
- `lines` (list of string, required) — Sångtexten i avsnittet. Högst 30 rader per avsnitt och högst 200 tecken per rad.
- `source_from` (SectionSource, optional, nullable) — Valfri källa att extrahera avsnittet från. Används för inpainting.

### CompositionPlanChunksItems

### SectionSource

- `song_id` (string, required) — ID:t för låten som avsnittet ska hämtas från. Du hittar låt-ID:t i svarens headers när du genererar en låt.
- `range` (TimeRange, required) — Intervallet som ska extraheras från källåten.
- `negative_ranges` (list of TimeRange, optional) — Intervallen som ska uteslutas från 'range'.

### GenerationChunk-Input

- `text` (string, required) — Textkonfigurationen som ska genereras för detta segment. Kan innehålla ett valfritt avsnittsnamn inom hakparenteser i början, t.ex. \[Verse 1], textrader och instruktioner i klammerparenteser, t.ex. \{scratching}. Avsnittsnamn måste vara mellan 1 och 100 tecken. Högst 30 rader tillåts, med högst 200 tecken per rad.
- `duration_ms` (integer, required) — Segmentets längd i millisekunder. Måste vara mellan 3000 ms och 120000 ms.
- `positive_styles` (list of string, required) — Stilarna och musikaliska riktningarna som ska finnas i detta segment. Använd engelska för bäst resultat. Stilarna för det första segmentet är viktigast eftersom de anger låtens övergripande ton och genre. Stilar för efterföljande segment kan användas för att lägga till nyanser, utveckling eller betoning, eller för att ändra låtens riktning. Sikta på minst 6–7 stilar i de tidiga segmenten tills riktningen har etablerats. Generella stilar som 'great production quality' är bra standardstilar att lägga till i listan.
- `negative_styles` (list of string, optional) — Stilarna och musikaliska riktningarna som inte ska finnas i detta segment. Använd engelska för bäst resultat. Att lämna fältet tomt är ett bra standardval; använd det bara om du uttryckligen vill undvika en viss stil eller riktning.
- `context_adherence` (enum, optional, default: high) — Hur mycket modellen följer kontexten i de omgivande delarna. Låg följsamhet innebär att modellen kan avvika från kontexten och vara mer kreativ. Hög följsamhet innebär att modellen blir mer konsekvent med kontexten.
  - Allowed values: `low`, `medium`, `high`
- `conditioning_ref` (AudioRefChunk, optional, nullable) — Ljudreferensen som genereringen ska baseras på. Det första segmentet är viktigast eftersom det påverkar genereringen av alla efterföljande segment. Om du vill tillämpa styrningen på hela låten ska du därför börja med det första segmentet.
- `condition_strength` (enum, optional, nullable) — Hur nära modellen följer den styrande referensen. Låg styrka innebär att modellen blir mer kreativ och avviker mer från referensen. Hög styrka innebär att modellen följer referensen mer konsekvent.
  - Allowed values: `low`, `medium`, `high`, `xhigh`

### AudioRefChunk

- `song_id` (string, required) — ID:t för låten som segmentet ska hämtas från. Du hittar låt-ID:t i svarens headers när du genererar en låt.
- `range` (TimeRange, required) — Tidsintervallet som ska extraheras från låten.

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