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

# Strumieniuj skomponowaną muzykę ze szczegółową odpowiedzią

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

Strumieniuj utwór i jego szczegółowe metadane za pomocą 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) — Format wyjściowy wygenerowanego audio. Ma postać codec_sample_rate_bitrate. Użyj "auto" (domyślne), aby API wybrało najlepszy format dla wybranego modelu: mp3_44100_128 dla modeli v1 i mp3_48000_192 dla modeli v2.
  - 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) — Gdy enable_logging ma wartość false, dla żądania zostanie użyty tryb zerowej retencji. Z trybu zerowej retencji mogą korzystać tylko klienci Enterprise.

### Body (application/json)

This endpoint expects a Body_Stream_composed_music_with_a_detailed_response_v1_music_detailed_stream_post.

- `prompt` (string, optional, nullable) — Prosty prompt tekstowy do wygenerowania utworu. Nie można go używać razem z `composition_plan`.
- `composition_plan` (BodyStreamComposedMusicWithADetailedResponseV1MusicDetailedStreamPostCompositionPlan, optional, nullable) — Szczegółowy plan kompozycji sterujący generowaniem muzyki. Nie można go używać razem z `prompt`.
- `music_length_ms` (integer, optional, nullable) — Długość generowanego utworu w milisekundach. Używane tylko z `prompt`. Musi wynosić od 3000 ms do 600000 ms. Opcjonalne — jeśli nie podano, model wybierze długość na podstawie promptu.
- `model_id` (enum, optional, default: music_v1) — Model do użycia przy generowaniu.
  - Allowed values: `music_v1`, `music_v2`, `music_v2_5`
- `seed` (integer, optional, nullable) — Losowy seed inicjujący generowanie muzyki. Użycie tego samego seedu z tymi samymi parametrami może dać bardziej spójne wyniki, ale dokładna powtarzalność nie jest gwarantowana, a wyniki mogą się zmieniać po aktualizacjach systemu. Nie można używać razem z prompt.
- `force_instrumental` (boolean, optional, default: false) — Jeśli ma wartość true, gwarantuje, że wygenerowany utwór będzie instrumentalny. Jeśli ma wartość false, utwór może być instrumentalny lub nie, zależnie od `prompt`. Można używać tylko z `prompt`.
- `finetune_id` (string, optional, nullable) — ID Finetune do użycia w generacji
- `store_for_inpainting` (boolean, optional, default: false) — Czy przechowywać wygenerowany utwór do inpaintingu.
- `with_timestamps` (boolean, optional, default: false) — Czy zwracać znaczniki czasu słów w wygenerowanym utworze.
- `with_waveform_visual` (boolean, optional, default: false) — Czy zwracać wizualną formę fali wygenerowanego utworu.

## Response

### 200

Zdarzenia Server-Sent Events dla planu kompozycji, metadanych utworu, fragmentów audio z opcjonalnymi znacznikami czasu słów i wizualną falą dźwiękową oraz zakończenia.

- Streaming response of `string`.

## Errors

### 422 Unprocessable Entity Error

Błąd walidacji

- `detail` (list of ValidationError, optional)

## Types

### BodyStreamComposedMusicWithADetailedResponseV1MusicDetailedStreamPostCompositionPlan

Szczegółowy plan kompozycji sterujący generowaniem muzyki. Nie można go używać razem z `prompt`.

- MusicPrompt: MusicPrompt
- CompositionPlan: CompositionPlan

### ValidationError

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

### MusicPrompt

Plan kompozycji dla modelu `music_v1`. Użycie tego pola z innym modelem spowoduje błąd.

- `positive_global_styles` (list of string, required) — Style i wskazówki muzyczne, które powinny występować w całym utworze. Aby uzyskać najlepszy wynik, użyj języka angielskiego.
- `negative_global_styles` (list of string, required) — Style i wskazówki muzyczne, które nie powinny występować w całym utworze. Aby uzyskać najlepszy wynik, użyj języka angielskiego.
- `sections` (list of SongSection, required) — Sekcje utworu.

### CompositionPlan

Plan kompozycji dla modeli `music_v2` i `music_v2_5`. Użycie tego pola z innym modelem spowoduje błąd.

- `chunks` (list of CompositionPlanChunksItems, required) — Fragmenty składające się na generowanie.

### ValidationErrorLocItems

- string
- integer

### SongSection

- `section_name` (string, required) — Nazwa sekcji. Musi mieć od 1 do 100 znaków.
- `positive_local_styles` (list of string, required) — Style i wskazówki muzyczne, które powinny występować w tej sekcji. Aby uzyskać najlepszy wynik, użyj języka angielskiego.
- `negative_local_styles` (list of string, required) — Style i wskazówki muzyczne, które nie powinny występować w tej sekcji. Aby uzyskać najlepszy wynik, użyj języka angielskiego.
- `duration_ms` (integer, required) — Czas trwania sekcji w milisekundach. Musi wynosić od 3000 ms do 120000 ms.
- `lines` (list of string, required) — Tekst sekcji. Maks. 30 wersów na sekcję i 200 znaków na wers.
- `source_from` (SectionSource, optional, nullable) — Opcjonalne źródło, z którego zostanie wyodrębniona sekcja. Używane do inpaintingu.

### CompositionPlanChunksItems

- GenerationChunk: GenerationChunk-Input
- AudioRefChunk: AudioRefChunk

### SectionSource

- `song_id` (string, required) — ID utworu, z którego pobrać sekcję. ID utworu znajdziesz w nagłówkach odpowiedzi podczas generowania utworu.
- `range` (TimeRange, required) — Zakres do wyodrębnienia z utworu źródłowego.
- `negative_ranges` (list of TimeRange, optional) — Zakresy do wykluczenia z „range”.

### GenerationChunk-Input

- `text` (string, required) — Konfiguracja tekstu do wygenerowania dla tego fragmentu. Może zawierać opcjonalną nazwę sekcji w nawiasach kwadratowych na początku, np. \[Verse 1], wersy tekstu i instrukcje w nawiasach klamrowych, np. \{scratching}. Nazwy sekcji muszą mieć od 1 do 100 znaków. Dozwolone jest maksymalnie 30 wierszy, każdy o długości do 200 znaków.
- `duration_ms` (integer, required) — Czas trwania fragmentu w milisekundach. Musi wynosić od 3000 ms do 120000 ms.
- `positive_styles` (list of string, required) — Style i wskazówki muzyczne, które powinny występować w tym fragmencie. Aby uzyskać najlepsze wyniki, użyj języka angielskiego. Style pierwszego fragmentu są najważniejsze, bo określają ogólny charakter i gatunek. Style kolejnych fragmentów mogą dodać niuanse, rozwój, akcenty lub zmienić kierunek utworu. We wczesnych fragmentach podaj co najmniej 6–7 stylów, aż kierunek będzie ustalony. Ogólne style, takie jak „great production quality”, dobrze sprawdzają się jako domyślne dodatki do listy.
- `negative_styles` (list of string, optional) — Style i wskazówki muzyczne, które nie powinny występować w tym fragmencie. Aby uzyskać najlepsze wyniki, użyj języka angielskiego. Domyślnie najlepiej zostawić to pole puste; użyj go tylko, jeśli chcesz wyraźnie uniknąć określonego stylu lub kierunku.
- `context_adherence` (enum, optional, default: high) — Jak bardzo model trzyma się kontekstu otaczających fragmentów. Niska zgodność oznacza, że model może odbiegać od kontekstu i być bardziej kreatywny. Wysoka zgodność oznacza większą spójność modelu z kontekstem.
  - Allowed values: `low`, `medium`, `high`
- `conditioning_ref` (AudioRefChunk, optional, nullable) — Referencja audio, na której oprze się generowanie. Pierwszy fragment jest najważniejszy, ponieważ wpłynie na generowanie wszystkich kolejnych fragmentów. Jeśli chcesz zastosować warunkowanie do całego utworu, zacznij od pierwszego fragmentu.
- `condition_strength` (enum, optional, nullable) — Jak bardzo model trzyma się referencji warunkującej. Niska wartość oznacza, że model będzie bardziej kreatywny i może odbiegać od referencji. Wysoka wartość oznacza większą zgodność modelu z referencją.
  - Allowed values: `low`, `medium`, `high`, `xhigh`

### AudioRefChunk

- `song_id` (string, required) — ID utworu, z którego pobrać fragment. ID utworu znajdziesz w nagłówkach odpowiedzi podczas generowania utworu.
- `range` (TimeRange, required) — Zakres czasu do wyodrębnienia z utworu.

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