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

# Composer de la musique

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

Compose une chanson à partir d'un prompt ou d'un plan de composition.

Reference: https://elevenlabs.io/docs/api-reference/music/compose

## 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 de sortie de l'audio généré. Formaté sous la forme codec_sample_rate_bitrate. Utilisez "auto", la valeur par défaut, pour laisser l'API choisir le format le plus adapté au modèle sélectionné : mp3_44100_128 pour les modèles v1 et mp3_48000_192 pour les modèles 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) — Lorsque enable_logging est défini sur false, le mode zéro rétention est utilisé pour la requête. Le mode zéro rétention est réservé aux clients Enterprise.

### Body (application/json)

This endpoint expects a Body_Compose_music_v1_music_post.

- `prompt` (string, optional, nullable) — Un prompt textuel simple à partir duquel générer un morceau. Ne peut pas être utilisé avec `composition_plan`.
- `composition_plan` (BodyComposeMusicV1MusicPostCompositionPlan, optional, nullable) — Plan de composition détaillé pour guider la génération de musique. Ne peut pas être utilisé conjointement avec `prompt`.
- `music_length_ms` (integer, optional, nullable) — La durée de la chanson à générer, en millisecondes. Utilisée uniquement avec `prompt`. Elle doit être comprise entre 3 000 ms et 600 000 ms. Facultatif : si elle n’est pas fournie, le modèle choisira une durée en fonction du prompt.
- `model_id` (enum, optional, default: music_v1) — Le modèle à utiliser pour la génération.
  - Allowed values: `music_v1`, `music_v2`, `music_v2_5`
- `seed` (integer, optional, nullable) — Graine aléatoire pour initialiser le processus de génération musicale. Fournir la même graine avec les mêmes paramètres peut aider à obtenir des résultats plus cohérents, mais la reproductibilité exacte n’est pas garantie et les sorties peuvent changer lors des mises à jour du système. Ne peut pas être utilisé avec prompt.
- `force_instrumental` (boolean, optional, default: false) — Si true, garantit que la chanson générée sera instrumentale. Si false, la chanson peut être instrumentale ou non selon le `prompt`. Peut uniquement être utilisé avec `prompt`.
- `finetune_id` (string, optional, nullable) — L’ID du Finetune à utiliser pour la génération
- `respect_sections_durations` (boolean, optional, default: true) — Contrôle la rigueur avec laquelle les durées des sections définies dans le `composition_plan` sont appliquées. Utilisé uniquement avec `composition_plan` et applicable seulement à `music_v1` ; pour `music_v2` et `music_v2_5`, les durées des sections sont toujours appliquées et ce paramètre est ignoré. Lorsque sa valeur est false pour `music_v1`, le modèle peut ajuster la durée de chaque section pour améliorer la qualité et la latence, tout en préservant la durée totale du morceau définie dans le plan.
- `store_for_inpainting` (boolean, optional, default: false) — Indique s'il faut stocker le morceau généré pour l'inpainting.
- `sign_with_c2pa` (boolean, optional, default: false) — Indique s'il faut signer le morceau généré avec C2PA. S'applique uniquement aux fichiers MP3.

## Response

### 200

Le fichier audio généré au format spécifié

- File download.

## Errors

### 422 Unprocessable Entity Error

Erreur de validation

- `detail` (list of ValidationError, optional)

## Types

### BodyComposeMusicV1MusicPostCompositionPlan

Plan de composition détaillé pour guider la génération de musique. Ne peut pas être utilisé conjointement avec `prompt`.

- MusicPrompt: MusicPrompt
- CompositionPlan: CompositionPlan

### ValidationError

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

### MusicPrompt

Plan de composition pour le modèle `music_v1`. L'utilisation de ce champ avec tout autre modèle entraîne une erreur.

- `positive_global_styles` (list of string, required) — Les styles et orientations musicales à intégrer à l’ensemble du morceau. Utilisez l’anglais pour de meilleurs résultats.
- `negative_global_styles` (list of string, required) — Les styles et orientations musicales à exclure de l’ensemble du morceau. Utilisez l’anglais pour de meilleurs résultats.
- `sections` (list of SongSection, required) — Les sections de la chanson.

### CompositionPlan

Plan de composition pour les modèles `music_v2` et `music_v2_5`. L'utilisation de ce champ avec tout autre modèle entraîne une erreur.

- `chunks` (list of CompositionPlanChunksItems, required) — Segments composant la génération.

### ValidationErrorLocItems

- string
- integer

### SongSection

- `section_name` (string, required) — Le nom de la section. Doit comporter entre 1 et 100 caractères.
- `positive_local_styles` (list of string, required) — Les styles et orientations musicales à intégrer à cette section. Utilisez l’anglais pour de meilleurs résultats.
- `negative_local_styles` (list of string, required) — Les styles et orientations musicales à exclure de cette section. Utilisez l’anglais pour de meilleurs résultats.
- `duration_ms` (integer, required) — La durée de la section en millisecondes. Doit être comprise entre 3 000 ms et 120 000 ms.
- `lines` (list of string, required) — Les paroles de la section. Maximum 30 lignes par section et 200 caractères par ligne.
- `source_from` (SectionSource, optional, nullable) — Source facultative dont extraire la section. Utilisée pour l'inpainting.

### CompositionPlanChunksItems

- GenerationChunk: GenerationChunk-Input
- AudioRefChunk: AudioRefChunk

### SectionSource

- `song_id` (string, required) — L’ID de la chanson à partir de laquelle extraire la section. Vous trouverez l’ID de la chanson dans les en-têtes de réponse lorsque vous générez une chanson.
- `range` (TimeRange, required) — La plage à extraire de la chanson source.
- `negative_ranges` (list of TimeRange, optional) — Les plages à exclure de « range ».

### GenerationChunk-Input

- `text` (string, required) — La configuration de texte à générer pour ce segment. Elle peut contenir un nom de section facultatif entre crochets au début, par exemple \[Verse 1], des lignes de paroles et des indications intégrées entre accolades, par exemple \{scratching}. Les noms de section doivent comporter entre 1 et 100 caractères. Un maximum de 30 lignes est autorisé, avec au plus 200 caractères par ligne.
- `duration_ms` (integer, required) — La durée du segment en millisecondes. Doit être comprise entre 3 000 ms et 120 000 ms.
- `positive_styles` (list of string, required) — Les styles et orientations musicales à intégrer à ce segment. Utilisez l’anglais pour de meilleurs résultats. Les styles du premier segment sont les plus importants, car ils définissent le ton général et le genre. Les styles des segments suivants peuvent apporter des nuances, une progression, une emphase ou modifier l’orientation du morceau. Visez au moins 6 à 7 styles dans les premiers segments, jusqu’à ce que l’orientation soit établie. Des styles génériques comme « great production quality » constituent de bonnes valeurs par défaut à ajouter à la liste.
- `negative_styles` (list of string, optional) — Les styles et orientations musicales à exclure de ce segment. Utilisez l’anglais pour de meilleurs résultats. Laisser ce champ vide est recommandé par défaut, ne l’utilisez que si vous souhaitez explicitement éviter un style ou une orientation en particulier.
- `context_adherence` (enum, optional, default: high) — Niveau d’adhérence du modèle au contexte des segments qui l’entourent. Une faible adhérence permet au modèle de s’écarter du contexte et d’être plus créatif. Une adhérence élevée rend le modèle plus cohérent avec le contexte.
  - Allowed values: `low`, `medium`, `high`
- `conditioning_ref` (AudioRefChunk, optional, nullable) — Référence audio utilisée pour conditionner la génération. Le premier segment est le plus important, car il influence la génération de tous les segments suivants. Pour conditionner l’ensemble de la chanson, commencez dès le premier segment.
- `condition_strength` (enum, optional, nullable) — Intensité avec laquelle le modèle respecte la référence de conditionnement. Une faible intensité rend le modèle plus créatif et l’éloigne de la référence. Une intensité élevée rend le modèle plus cohérent avec la référence.
  - Allowed values: `low`, `medium`, `high`, `xhigh`

### AudioRefChunk

- `song_id` (string, required) — L’ID de la chanson à partir de laquelle extraire le segment. Vous trouverez l’ID de la chanson dans les en-têtes de réponse lorsque vous générez une chanson.
- `range` (TimeRange, required) — La plage temporelle à extraire du morceau.

### TimeRange

- `start_ms` (integer, required)
- `end_ms` (integer, required)

## Examples

**Request**

```json
{}
```

**SDK Code**

```python
import requests

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

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';
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"

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

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")
  .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', [
  'body' => '{}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.elevenlabs.io/v1/music");
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")! 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()
```