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

# Wygeneruj plan kompozycji

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

Utwórz plan kompozycji do generowania muzyki. Korzystanie z tego endpointu nie kosztuje kredytów, ale podlega limitom zależnym od twojego planu.

Reference: https://elevenlabs.io/docs/api-reference/music/create-composition-plan

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

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

- `prompt` (string, required) — Prosty prompt tekstowy do utworzenia planu.
- `music_length_ms` (integer, optional, nullable) — Długość generowanego planu kompozycji w milisekundach. Musi wynosić od 3000 ms do 600000 ms. Opcjonalne — jeśli nie podano, model wybierze długość na podstawie promptu.
- `source_composition_plan` (BodyGenerateCompositionPlanV1MusicPlanPostSourceCompositionPlan, optional, nullable) — Opcjonalny plan kompozycji, który posłuży jako źródło dla nowego planu kompozycji.
- `model_id` (enum, optional, default: music_v1) — Model do użycia przy generowaniu.
  - Allowed values: `music_v1`, `music_v2`, `music_v2_5`

## Response

### 200

Pomyślna odpowiedź

- `music_composition_plan_create_Response_200`
  - MusicPrompt: MusicPrompt
  - CompositionPlan: CompositionPlan

## Errors

### 422 Unprocessable Entity Error

Błąd walidacji

- `detail` (list of ValidationError, optional)

## Types

### BodyGenerateCompositionPlanV1MusicPlanPostSourceCompositionPlan

Opcjonalny plan kompozycji, który posłuży jako źródło dla nowego planu kompozycji.

- MusicPrompt: MusicPrompt
- CompositionPlan: CompositionPlan

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

### ValidationError

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

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

### ValidationErrorLocItems

- string
- integer

### 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
{
  "prompt": "string"
}
```

**Response**

```json
{
  "negative_global_styles": [
    "metal",
    "hip-hop",
    "country"
  ],
  "positive_global_styles": [
    "pop",
    "rock",
    "jazz"
  ],
  "sections": [
    {
      "duration_ms": 10000,
      "lines": [
        "Verse 1 lyrics"
      ],
      "negative_local_styles": [
        "metal",
        "hip-hop",
        "country"
      ],
      "positive_local_styles": [
        "pop",
        "rock",
        "jazz"
      ],
      "section_name": "Verse 1"
    }
  ]
}
```

**SDK Code**

```python
import requests

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

payload = { "prompt": "string" }
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/plan';
const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: '{"prompt":"string"}'
};

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/plan"

	payload := strings.NewReader("{\n  \"prompt\": \"string\"\n}")

	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/plan")

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 = "{\n  \"prompt\": \"string\"\n}"

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/plan")
  .header("Content-Type", "application/json")
  .body("{\n  \"prompt\": \"string\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

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

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

```csharp
using RestSharp;

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

```swift
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.elevenlabs.io/v1/music/plan")! 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()
```