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

# Compositieplan genereren

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

Maak een compositieplan voor muziekgeneratie. Het gebruik van dit endpoint kost geen credits, maar is afhankelijk van je tier onderworpen aan rate limiting.

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

### Body (application/json)

This endpoint expects a Body_Generate_composition_plan_v1_music_plan_post.

- `prompt` (string, required) — Een eenvoudige tekstprompt om een plan mee op te stellen.
- `music_length_ms` (integer, optional, nullable) — De lengte van het te genereren compositieplan in milliseconden. Moet tussen 3000 ms en 600000 ms liggen. Optioneel: als je geen waarde opgeeft, kiest het model een lengte op basis van de prompt.
- `source_composition_plan` (BodyGenerateCompositionPlanV1MusicPlanPostSourceCompositionPlan, optional, nullable) — Een optioneel compositieplan dat als bron voor het nieuwe compositieplan wordt gebruikt.
- `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`

## Response

### 200

Geslaagde response

- `music_composition_plan_create_Response_200`

## Errors

### 422 Unprocessable Entity Error

Validatiefout

- `detail` (list of ValidationError, optional)

## Types

### BodyGenerateCompositionPlanV1MusicPlanPostSourceCompositionPlan

Een optioneel compositieplan dat als bron voor het nieuwe compositieplan wordt gebruikt.

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

### ValidationError

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

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

### ValidationErrorLocItems

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