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

# Generar plan de composición

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

Crea un plan de composición para generar música. El uso de esta ruta de API no consume créditos, pero está sujeto a límites de frecuencia según tu plan.

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) — Cuando enable_logging se establece en false, se usará el modo de retención cero para la solicitud. El modo de retención cero solo puede utilizarse por clientes Enterprise.

### Body (application/json)

This endpoint expects a Body_Generate_composition_plan_v1_music_plan_post.

- `prompt` (string, required) — Un prompt de texto sencillo a partir del que componer un plan.
- `music_length_ms` (integer, optional, nullable) — La duración del plan de composición que se generará, en milisegundos. Debe estar entre 3000 ms y 600000 ms. Opcional: si no se proporciona, el modelo elegirá una duración según el prompt.
- `source_composition_plan` (BodyGenerateCompositionPlanV1MusicPlanPostSourceCompositionPlan, optional, nullable) — Un plan de composición opcional para usar como fuente del nuevo plan de composición.
- `model_id` (enum, optional, default: music_v1) — El modelo que se debe usar para la generación.
  - Allowed values: `music_v1`, `music_v2`, `music_v2_5`

## Response

### 200

Respuesta correcta.

- `music_composition_plan_create_Response_200`

## Errors

### 422 Unprocessable Entity Error

Error de validación

- `detail` (list of ValidationError, optional)

## Types

### BodyGenerateCompositionPlanV1MusicPlanPostSourceCompositionPlan

Un plan de composición opcional para usar como fuente del nuevo plan de composición.

### MusicPrompt

Plan de composición para el modelo `music_v1`. Usar este campo con cualquier otro modelo producirá un error.

- `positive_global_styles` (list of string, required) — Los estilos y las indicaciones musicales que deben estar presentes en toda la canción. Usa el inglés para obtener mejores resultados.
- `negative_global_styles` (list of string, required) — Los estilos y las indicaciones musicales que no deben estar presentes en toda la canción. Usa el inglés para obtener mejores resultados.
- `sections` (list of SongSection, required) — Las secciones de la canción.

### CompositionPlan

Plan de composición para los modelos `music_v2` y `music_v2_5`. Usar este campo con cualquier otro modelo producirá un error.

- `chunks` (list of CompositionPlanChunksItems, required) — Los fragmentos que componen la generación.

### ValidationError

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

### SongSection

- `section_name` (string, required) — El nombre de la sección. Debe tener entre 1 y 100 caracteres.
- `positive_local_styles` (list of string, required) — Los estilos y las indicaciones musicales que deben estar presentes en esta sección. Usa el inglés para obtener mejores resultados.
- `negative_local_styles` (list of string, required) — Los estilos y las indicaciones musicales que no deben estar presentes en esta sección. Usa el inglés para obtener mejores resultados.
- `duration_ms` (integer, required) — La duración de la sección en milisegundos. Debe estar entre 3000 ms y 120000 ms.
- `lines` (list of string, required) — La letra de la sección. Máximo de 30 líneas por sección y 200 caracteres por línea.
- `source_from` (SectionSource, optional, nullable) — Fuente opcional de la que extraer la sección. Se utiliza para el inpainting.

### CompositionPlanChunksItems

### ValidationErrorLocItems

### SectionSource

- `song_id` (string, required) — El ID de la canción de la que se obtendrá la sección. Puedes encontrar el ID de la canción en las cabeceras de respuesta al generar una canción.
- `range` (TimeRange, required) — El intervalo que se debe extraer de la canción de origen.
- `negative_ranges` (list of TimeRange, optional) — Los intervalos que se deben excluir del «range».

### GenerationChunk-Input

- `text` (string, required) — La configuración de texto que se generará para este fragmento. Puede contener un nombre de sección opcional entre corchetes al principio, por ejemplo, \[Verse 1], líneas de letra e indicaciones en línea entre llaves, por ejemplo, \{scratching}. Los nombres de sección deben tener entre 1 y 100 caracteres. Se permiten como máximo 30 líneas, de hasta 200 caracteres cada una.
- `duration_ms` (integer, required) — La duración del fragmento en milisegundos. Debe estar entre 3000 ms y 120000 ms.
- `positive_styles` (list of string, required) — Los estilos y las indicaciones musicales que deben estar presentes en este fragmento. Usa el inglés para obtener mejores resultados. Los estilos del primer fragmento son los más importantes, ya que definen el tono y el género generales. Los estilos de los fragmentos posteriores pueden usarse para añadir matices, progresión o énfasis, o para cambiar la dirección de la canción. Intenta incluir al menos 6-7 estilos en los primeros fragmentos hasta que se establezca la dirección. Los estilos genéricos como 'great production quality' son buenos estilos predeterminados para añadir a la lista.
- `negative_styles` (list of string, optional) — Los estilos y las indicaciones musicales que no deben estar presentes en este fragmento. Usa el inglés para obtener mejores resultados. Dejarlo vacío es una buena opción predeterminada; utiliza este campo solo si quieres evitar explícitamente un estilo o una dirección concretos.
- `context_adherence` (enum, optional, default: high) — Hasta qué punto el modelo se ajusta al contexto de los fragmentos que lo rodean. Una adherencia baja permite que el modelo se aleje del contexto y sea más creativo. Una adherencia alta hace que el modelo sea más coherente con el contexto.
  - Allowed values: `low`, `medium`, `high`
- `conditioning_ref` (AudioRefChunk, optional, nullable) — La referencia de audio que condicionará la generación. El primer fragmento es el más importante, ya que influirá en la generación de todos los fragmentos posteriores. Por tanto, si quieres aplicar el condicionamiento a toda la canción, empieza por el primer fragmento.
- `condition_strength` (enum, optional, nullable) — Con qué intensidad el modelo se ajusta a la referencia de condicionamiento. Una intensidad baja hace que el modelo sea más creativo y se aleje de la referencia. Una intensidad alta hace que el modelo sea más coherente con la referencia.
  - Allowed values: `low`, `medium`, `high`, `xhigh`

### AudioRefChunk

- `song_id` (string, required) — El ID de la canción de la que se obtendrá el fragmento. Puedes encontrar el ID de la canción en las cabeceras de respuesta al generar una canción.
- `range` (TimeRange, required) — El intervalo de tiempo que se extraerá de la canción.

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