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

# Démarrage rapide de Music

Ce guide vous montre comment générer de la musique avec notre API Music.

> **Tip**
>
> Utilisez la [compétence Music d’ElevenLabs](https://github.com/elevenlabs/skills/tree/main/music) pour générer des morceaux avec votre assistant de programmation IA :
>
> ```bash
> npx skills add elevenlabs/skills --skill music
> ```

> **Info**
>
> L’API Music est réservée aux utilisateurs payants.

## Utiliser l’API Music

#### Créer une clé API

[Créez une clé API dans le Dashboard ici](https://elevenlabs.io/app/api/api-keys), que vous utiliserez pour [accéder à l’API](/docs/fr/api-reference/authentication) en toute sécurité.

Stockez la clé comme secret géré et transmettez-la aux SDK, soit sous forme de variable d’environnement via un fichier `.env`, soit directement dans la configuration de votre application, selon vos préférences.

**`.env`**

```js title=".env"
ELEVENLABS_API_KEY=<your_api_key_here>
```

#### Installer le SDK

#### SDK

Nous utiliserons également la bibliothèque `dotenv` pour charger notre clé API depuis une variable d'environnement.

```python
pip install elevenlabs
pip install python-dotenv
```

```typescript
npm install @elevenlabs/elevenlabs-js
npm install dotenv
```

#### CLI

Installez la CLI ElevenLabs. Homebrew (macOS) et Scoop (Windows) sont recommandés.

**`Homebrew (macOS)`**

```bash title="Homebrew (macOS)"
brew install elevenlabs/tap/elevenlabs
```

**`Scoop (Windows)`**

```powershell title="Scoop (Windows)"
scoop bucket add elevenlabs https://github.com/elevenlabs/scoop-bucket
scoop install elevenlabs
```

**`npm`**

```bash title="npm"
npm install -g @elevenlabs/cli
```

**`curl`**

```bash title="curl"
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/elevenlabs/cli/releases/latest/download/elevenlabs-cli-installer.sh | sh
```

> **Tip**
>
> Vous travaillez avec un assistant de programmation IA ? Exécutez `elevenlabs generate-skills` dans votre projet pour créer un
> fichier `SKILL.md` pour chaque groupe de commandes dans `skills/`, afin que votre assistant connaisse toutes les fonctionnalités de la CLI
> sans que vous ayez à copier la documentation. Utilisez `--output-dir` pour les placer ailleurs. Cette commande lit la propre
> définition d'API intégrée à la CLI, elle ne nécessite donc aucune clé API et fonctionne hors ligne, tout en restant synchronisée avec
> la version de la CLI que vous avez installée.

Authentifiez-vous ensuite, votre navigateur s'ouvrira pour autoriser la CLI :

```bash
elevenlabs auth login
```

#### Effectuer la requête API

#### SDK

Créez un fichier nommé `example.py` ou `example.mts`, selon le langage choisi, puis ajoutez le code suivant :

```python
# example.py
from elevenlabs.client import ElevenLabs
from elevenlabs.play import play
import os
from dotenv import load_dotenv
load_dotenv()

elevenlabs = ElevenLabs(
    api_key=os.getenv("ELEVENLABS_API_KEY"),
)

track = elevenlabs.music.compose(
    prompt="Create an intense, fast-paced electronic track for a high-adrenaline video game scene. Use driving synth arpeggios, punchy drums, distorted bass, glitch effects, and aggressive rhythmic textures. The tempo should be fast, 130–150 bpm, with rising tension, quick transitions, and dynamic energy bursts.",
    music_length_ms=10000,
    model_id="music_v2_5",
)

# Save the track to a file
with open("path/to/music.mp3", "wb") as f:
    for chunk in track:
        f.write(chunk)
```

```typescript
// example.mts
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import { Readable } from "stream";
import { createWriteStream } from "fs";
import { pipeline } from "stream/promises";
import "dotenv/config";

const elevenlabs = new ElevenLabsClient();

const track = await elevenlabs.music.compose({
  prompt: "Create an intense, fast-paced electronic track for a high-adrenaline video game scene. Use driving synth arpeggios, punchy drums, distorted bass, glitch effects, and aggressive rhythmic textures. The tempo should be fast, 130–150 bpm, with rising tension, quick transitions, and dynamic energy bursts.",
  musicLengthMs: 10000,
  modelId: "music_v2_5",
});

// Save the track to a file
await pipeline(Readable.from(track), createWriteStream("path/to/music.mp3"));
```

Exécutez-le ensuite :

```python
python example.py
```

```typescript
npx tsx example.mts
```

Vous devriez entendre la musique générée.

#### CLI

Générez un morceau et enregistrez-le dans un fichier :

```bash
elevenlabs music compose \
  --prompt "Create an intense, fast-paced electronic track for a high-adrenaline video game scene. Use driving synth arpeggios, punchy drums, distorted bass, glitch effects, and aggressive rhythmic textures. The tempo should be fast, 130–150 bpm, with rising tension, quick transitions, and dynamic energy bursts." \
  --music-length-ms 10000 \
  --model-id music_v2_5 \
  --output music.mp3
```

Ouvrez `music.mp3` pour écouter le résultat.

## Plans de composition

Un plan de composition est un objet JSON qui décrit plus précisément la musique à générer. Utilisez des prompts textuels pour le prototypage rapide et des plans de composition lorsque vous avez besoin d’une structure de segments spécifique, d’un minutage précis des paroles ou d’arrangements complexes.

#### [Guide des plans de composition](/docs/fr/eleven-api/guides/how-to/music/composition-plans)

Découvrez comment structurer des morceaux avec des segments, des styles et des paroles pour un contrôle précis.

### Générer un plan de composition

Vous pouvez générer un plan de composition à partir d’un prompt via l’API.

```python
from elevenlabs.client import ElevenLabs
from elevenlabs.play import play
import os
from dotenv import load_dotenv
load_dotenv()

elevenlabs = ElevenLabs(
api_key=os.getenv("ELEVENLABS_API_KEY"),
)

composition_plan = elevenlabs.music.composition_plan.create(
    prompt="Create an intense, fast-paced electronic track for a high-adrenaline video game scene. Use driving synth arpeggios, punchy drums, distorted bass, glitch effects, and aggressive rhythmic textures. The tempo should be fast, 130–150 bpm, with rising tension, quick transitions, and dynamic energy bursts.",
    music_length_ms=10000,
    model_id="music_v2_5",
)

print(composition_plan)
```

```typescript
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import "dotenv/config";

const elevenlabs = new ElevenLabsClient();

const compositionPlan = await elevenlabs.music.compositionPlan.create({
  prompt: "Create an intense, fast-paced electronic track for a high-adrenaline video game scene. Use driving synth arpeggios, punchy drums, distorted bass, glitch effects, and aggressive rhythmic textures. The tempo should be fast, 130–150 bpm, with rising tension, quick transitions, and dynamic energy bursts.",
  musicLengthMs: 10000,
  modelId: "music_v2_5",
});

console.log(JSON.stringify(compositionPlan, null, 2));
```

Cela génère un plan de composition similaire au suivant :

```json
{
  "chunks": [
    {
      "text": "[Intro]",
      "durationMs": 3000,
      "positiveStyles": [
        "electronic",
        "fast-paced",
        "rising synth arpeggio",
        "glitch fx",
        "filtered noise sweep",
        "soft punchy kick building tension",
        "high adrenaline"
      ],
      "negativeStyles": ["soft pads", "melodic vocals", "ambient textures"],
      "contextAdherence": "high"
    },
    {
      "text": "[Peak Drop]",
      "durationMs": 4000,
      "positiveStyles": [
        "full punchy drums",
        "distorted bass stab",
        "aggressive rhythmic hits",
        "rapid arpeggio sequences"
      ],
      "negativeStyles": ["smooth transitions", "clean bass", "slow buildup"],
      "contextAdherence": "high"
    },
    {
      "text": "[Final Burst]",
      "durationMs": 3000,
      "positiveStyles": [
        "glitch stutter",
        "energy burst vox chopped sample",
        "quick transitions",
        "snare rolls"
      ],
      "negativeStyles": ["long reverb tails", "fadeout", "gentle melodies"],
      "contextAdherence": "high"
    }
  ]
}
```

### Utiliser un plan de composition

Vous pouvez générer de la musique à partir d’un plan de composition en le transmettant à la méthode `compose`.

```python
# You can pass in composition_plan or prompt, but not both.
composition = elevenlabs.music.compose(
    composition_plan=composition_plan,
    model_id="music_v2_5",
)

play(composition)
```

```typescript
// You can pass in compositionPlan or prompt, but not both.
const composition = await elevenlabs.music.compose({
    compositionPlan,
    modelId: "music_v2_5",
});

await play(composition);
```

## Générer de la musique avec des détails

Pour chaque génération musicale, un plan de composition est créé à partir du prompt. Vous pouvez choisir de récupérer ce plan en utilisant le point de terminaison de réponse détaillée.

```python
track_details = elevenlabs.music.compose_detailed(
    prompt="Create an intense, fast-paced electronic track for a high-adrenaline video game scene. Use driving synth arpeggios, punchy drums, distorted bass, glitch effects, and aggressive rhythmic textures. The tempo should be fast, 130–150 bpm, with rising tension, quick transitions, and dynamic energy bursts.",
    music_length_ms=10000,
    model_id="music_v2_5",
)

print(track_details.json) # json contains composition_plan and song_metadata. The composition plan will include lyrics (if applicable)
print(track_details.filename)
# track_details.audio contains the audio bytes
```

```typescript
const trackDetails = await elevenlabs.music.composeDetailed({
  prompt: 'Create an intense, fast-paced electronic track for a high-adrenaline video game scene. Use driving synth arpeggios, punchy drums, distorted bass, glitch effects, and aggressive rhythmic textures. The tempo should be fast, 30–150 bpm, with rising tension, quick transitions, and dynamic energy bursts.',
  musicLengthMs: 10000,
  modelId: "music_v2_5",
});

console.log(JSON.stringify(trackDetails.json, null, 2)); // json contains composition_plan and song_metadata. The composition plan will include lyrics (if applicable)
console.log(trackDetails.filename);
// trackDetails.audio contains the audio bytes
```

## Contenu protégé par le droit d’auteur

Toute tentative de générer de la musique ou un plan de composition contenant du contenu protégé par le droit d’auteur entraînera une erreur. Cela inclut la mention du nom d’un groupe ou d’un musicien, ou l’utilisation de paroles protégées par le droit d’auteur.

### Prompts contenant du contenu protégé par le droit d’auteur

Dans ces cas, l’API renvoie une erreur `bad_prompt` qui contient une suggestion de prompt à utiliser à la place.

```python
try:
    # This will result in a bad_prompt error
    track = elevenlabs.music.compose(
        prompt="A song that sounds like 'Bohemian Rhapsody'",
        music_length_ms=10000,
        model_id="music_v2_5",
    )
  except Exception as e:
      if e.body['detail']['status'] == 'bad_prompt':
          prompt_suggestion = e.body['detail']['data']['prompt_suggestion']
          print(prompt_suggestion) # Prints: An epic rock ballad with dramatic tempo changes, operatic harmonies, and a narrative structure that blends melancholy with bursts of theatrical intensity.

          # Use the prompt suggestion to generate the track instead
```

```typescript
try {
  // This will result in a bad_prompt error
  const track = await elevenlabs.music.compose({
    prompt: "A song that sounds like 'Bohemian Rhapsody'",
    musicLengthMs: 10000,
    modelId: "music_v2_5",
  });
} catch (error) {
  if (error.body.detail.status === 'bad_prompt') {
    const promptSuggestion = error.body.detail.data.prompt_suggestion;
    console.log(promptSuggestion); // Logs: An epic rock ballad with dramatic tempo changes, operatic harmonies, and a narrative structure that blends melancholy with bursts of theatrical intensity.

    // Use the prompt suggestion to generate the track instead
  }
}
```

### Plans de composition contenant du contenu protégé par le droit d’auteur

Si des styles utilisant du contenu protégé par le droit d’auteur sont employés lors de la génération d’un plan de composition, une erreur `bad_composition_plan` est renvoyée. Comme pour les prompts musicaux, un plan de composition suggéré `composition_plan_suggestion` est renvoyé dans l’erreur.

> **Warning**
>
> Lorsqu’un plan de composition ou un prompt contient du contenu préjudiciable, aucune suggestion de prompt
> n’est renvoyée.

## Étapes suivantes

#### [Diffuser de la musique](/docs/fr/eleven-api/guides/how-to/music/streaming)

Diffusez la musique générée en temps réel au lieu d’attendre le fichier complet

#### [Inpainting musical](/docs/fr/eleven-api/guides/how-to/music/inpainting)

Modifiez ou prolongez des sections spécifiques d’un morceau existant

#### [Guide de l’API](/docs/fr/api-reference/music/compose)

Découvrez tous les paramètres et formats de réponse de l’API Music