> 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 du clonage de voix professionnel

Ce guide vous explique comment créer un clonage de voix professionnel (PVC) à l’aide de l’API PVC. Pour créer un PVC via le Dashboard, consultez le guide produit [Professional Voice Clone](/docs/fr/eleven-creative/voices/voice-cloning/professional-voice-cloning).

> **Info**
>
> La création d’un PVC nécessite de disposer du [forfait Creator ou supérieur](https://elevenlabs.io/pricing).

Pour une explication détaillée du fonctionnement interne d’IVC et de PVC, et pour savoir lequel choisir, consultez [Clonage de voix : fonctionnement](/docs/fr/eleven-api/concepts/voice-cloning).

> **Warning**
>
> Si vous n’êtes pas certain de ce qui est autorisé sur le plan juridique, consultez les [Conditions d’utilisation](https://elevenlabs.io/terms-of-use) et nos [informations sur la sécurité de l’IA](https://elevenlabs.io/safety) pour en savoir plus.

Créer un PVC via l’API comporte beaucoup plus d’étapes que créer un clonage de voix instantané. Les PVC sont plus complexes et nécessitent davantage de données et d’affinage pour produire un clone de qualité.

## Utiliser l’API Professional Voice Clone

> **Note**
>
> Ce guide suppose que vous avez [configuré votre clé API et votre SDK](/docs/fr/eleven-api/quickstart). Terminez
> d’abord le démarrage rapide si ce n’est pas déjà fait.

#### Créer une voix PVC

Créez un fichier nommé `example.py` ou `example.mts`, selon le langage de votre choix, puis ajoutez le code suivant pour créer une voix PVC :

```python maxLines=0
# example.py
import os
import time
import base64
from contextlib import ExitStack
from io import BytesIO
from dotenv import load_dotenv
from elevenlabs.client import ElevenLabs

load_dotenv()

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

voice = elevenlabs.voices.pvc.create(
    name="My Professional Voice Clone",
    language="en",
    description="A professional voice clone of my voice"
)

print(voice)
```

```typescript maxLines=0
// example.mts
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import "dotenv/config";
import fs from "node:fs";

const elevenlabs = new ElevenLabsClient();

const voice = await elevenlabs.voices.pvc.create({
    name: "My Professional Voice Clone",
    language: "en",
    description: "A professional voice clone of my voice",
});

console.log(voice.voiceId);
```

#### Importer des fichiers audio

Importez ensuite les fichiers d’échantillons audio qui serviront à entraîner le PVC. Consultez la section [Conseils et suggestions](/docs/fr/eleven-creative/voices/voice-cloning/professional-voice-cloning#tips-and-suggestions) du guide produit PVC pour savoir comment obtenir les meilleurs résultats à partir de vos fichiers audio.

```python maxLines=0
# Define the list of file paths explicitly
# Replace with the paths to your audio and/or video files.
# The more files you add, the better the clone will be.
sample_file_paths = [
    "/path/to/your/first_sample.mp3",
    "/path/to/your/second_sample.wav",
    "relative/path/to/another_sample.mp4"
]

samples = None

files_to_upload = []
# Use ExitStack to manage multiple open files
with ExitStack() as stack:
    for filepath in sample_file_paths:
        # Open each file and add it to the stack
        audio_file = stack.enter_context(open(filepath, "rb"))
        filename = os.path.basename(filepath)

        # Create a File object for the SDK
        files_to_upload.append(
            BytesIO(audio_file.read())
        )

    samples = elevenlabs.voices.pvc.samples.create(
        voice_id=voice.voice_id,
        files=files_to_upload # Pass the list of File objects
    )
```

```typescript
const samples = await elevenlabs.voices.pvc.samples.create(voice.voiceId, {
    // Replace with the paths to your audio and/or video files.
    // The more files you add, the better the clone will be.
    files: [fs.createReadStream("/path/to/your/audio/file.mp3")],
})
```

#### Lancer la séparation des locuteurs

Cette étape tente de séparer les fichiers audio par locuteur. Elle est nécessaire si vous importez de l’audio comportant plusieurs locuteurs.

```python maxLines=0
sample_ids_to_check = []
for sample in samples:
    if sample.sample_id:
        print(f"Starting separation for sample: {sample.sample_id}")
        elevenlabs.voices.pvc.samples.speakers.separate(
            voice_id=voice.voice_id,
            sample_id=sample.sample_id
        )
        sample_ids_to_check.append(sample.sample_id)

while sample_ids_to_check:
    # Create a copy of the list to iterate over, so we can remove items from the original
    ids_in_batch = list(sample_ids_to_check)
    for sample_id in ids_in_batch:
        status_response = elevenlabs.voices.pvc.samples.speakers.get(
            voice_id=voice.voice_id,
            sample_id=sample_id
        )
        status = status_response.status
        print(f"Sample {sample_id} status: {status}")
        if status == "completed" or status == "failed":
            sample_ids_to_check.remove(sample_id)

    if sample_ids_to_check:
        # Wait before the next poll cycle
        time.sleep(5) # Wait for 5 seconds

print("All samples have been processed or removed from polling.")
```

```typescript maxLines=0
// Trigger the speaker separation action, this will take some time to complete
for (const sample of samples) {
    if (sample.sampleId) {
        await elevenlabs.voices.pvc.samples.speakers.separate(voiceId, sample.sampleId);
    }
}

// Check the status of the speaker separation action
const ids = samples.map((sample) => sample.sampleId);
const interval = setInterval(async () => {
    // Poll the status of the speaker separation action
    for (const id of ids) {
        if (!id) continue;

        const { status } = await elevenlabs.voices.pvc.samples.speakers.get(voice.voiceId, id);
        console.log(`Sample ${id} status: ${status}`);
        if (status === "completed" || status === "failed") {
            ids.splice(ids.indexOf(id), 1);
        }

        if (ids.length === 0) {
            clearInterval(interval);
            console.log("All samples have been processed or removed from polling");
        }
    }
}, 5000);
```

#### Récupérer l’audio des locuteurs

> **Warning**
>
> L’étape précédente prenant un certain temps, exécutez l’étape suivante dans un processus distinct après son achèvement.

Une fois la séparation des locuteurs terminée, vous disposerez d’une liste de locuteurs pour chaque échantillon. Pour les échantillons comportant plusieurs locuteurs, choisissez celui à utiliser pour le PVC. Vous pouvez récupérer l’audio de chaque locuteur et l’écouter pour l’identifier.

```python maxLines=0
# Get the list of samples from the voice created in Step 3
voice = elevenlabs.voices.get(voice_id=voice_id)

samples = voice.samples

# Loop over each sample and save the audio for each speaker to a file
speaker_audio_output_dir = "path/to/speakers/"
if not os.path.exists(speaker_audio_output_dir):
    os.makedirs(speaker_audio_output_dir)

for sample in samples:
    speaker_info = elevenlabs.voices.pvc.samples.speakers.get(
        voice_id=voice.voice_id,
        sample_id=sample.sample_id
    )

    # Proceed only if separation is actually complete
    if getattr(speaker_info, 'status', 'unknown') != "completed":
        continue

    if hasattr(speaker_info, 'speakers') and speaker_info.speakers:
        speaker_list = speaker_info.speakers
        if isinstance(speaker_info.speakers, dict):
            speaker_list = speaker_info.speakers.values()

        for speaker in speaker_list:
            audio_response = elevenlabs.voices.pvc.samples.speakers.audio.get(
                voice_id=voice.voice_id,
                sample_id=sample.sample_id,
                speaker_id=speaker.speaker_id
            )

            audio_base64 = audio_response.audio_base_64
            audio_data = base64.b64decode(audio_base64)
            output_filename = os.path.join(speaker_audio_output_dir, f"sample_{sample.sample_id}_speaker_{speaker.speaker_id}.mp3")

            with open(output_filename, "wb") as f:
                f.write(audio_data)
```

```typescript maxLines=0
// Get the list of samples from the voice created in Step 3
const { samples } = await elevenlabs.voices.get(voiceId);

// After separation is completed, get the list of speakers and their audio
if (samples) {
    for (const sample of samples) {
        if (!sample.sampleId) continue;

        const { speakers } = await elevenlabs.voices.pvc.samples.speakers.get(voiceId, sample.sampleId)

        if (speakers) {
            for (const speaker of Object.values(speakers)) {
                if (!speaker || !speaker.speakerId) continue;
                const { audioBase64 } = await elevenlabs.voices.pvc.samples.speakers.audio.get(voiceId, sample.sampleId, speaker.speakerId);
                const audioBuffer = Buffer.from(audioBase64, 'base64');

                // Write the audio to a file
                // Note which speaker ID you wish to use for the PVC
                fs.writeFileSync(`path/to/speakers/sample_${sample.sampleId}_speaker_${speaker.speakerId}.mp3`, audioBuffer);
            }
        }
    }
}
```

#### Mettre à jour les échantillons avec les ID de locuteur

Une fois la séparation des locuteurs terminée, vous pouvez mettre à jour les échantillons afin de sélectionner le locuteur à utiliser pour le PVC.

```python
elevenlabs.voices.pvc.samples.update(
    voice_id=voice.voice_id,
    sample_id=sample.sample_id,
    selected_speaker_ids=[speaker.speaker_id]
)
```

```typescript
await elevenlabs.voices.pvc.samples.update(voice.voiceId, sample.sampleId, {
    selectedSpeakerIds: [speaker.speakerId],
})
```

Répétez ce processus pour chaque échantillon comportant plusieurs locuteurs.

#### Vérifier le PVC

Avant de pouvoir commencer l’entraînement, une étape de vérification est requise pour garantir que vous êtes autorisé à utiliser la voix. Demandez d’abord le CAPTCHA de vérification.

```python
captcha_response = elevenlabs.voices.pvc.verification.captcha.get(voice.voice_id)

# Save captcha image to file
captcha_buffer = base64.b64decode(captcha_response)
with open('captcha.png', 'wb') as f:
    f.write(captcha_buffer)
```

```typescript
const captchaResponse = await elevenlabs.voices.pvc.verification.captcha.get(voice.voiceId);

// Save captcha image to file
const captchaBuffer = Buffer.from(captchaResponse, 'base64');
fs.writeFileSync('path/to/captcha.png', captchaBuffer);
```

L’image contient plusieurs lignes de texte que le propriétaire de la voix devra lire à voix haute et enregistrer. Une fois l’enregistrement effectué, envoyez-le afin de vérifier l’identité du propriétaire de la voix.

```python
elevenlabs.voices.pvc.verification.captcha.verify(
    voice_id=voice.voice_id,
    recording=open('path/to/recording.mp3', 'rb')
)
```

```typescript
await elevenlabs.voices.pvc.verification.captcha.verify(voice.voiceId, {
	recording: fs.createReadStream("/path/to/recording.mp3"),
})
```

#### (Facultatif) Demander une vérification manuelle

Si vous ne parvenez pas à vérifier le CAPTCHA, vous pouvez demander une vérification manuelle. Son traitement prendra plus de temps.

Utilisez cette option uniquement si les étapes de vérification précédentes ont échoué ou ne sont pas possibles, par exemple si le propriétaire de la voix est malvoyant.

Pour connaître la liste des fichiers requis pour une vérification manuelle, contactez l’assistance, car chaque cas peut être différent.

```python
elevenlabs.voices.pvc.verification.request(
    voice_id=voice.voice_id,
    files=[open('path/to/verification/files.txt', 'rb')],
)
```

```typescript
await elevenlabs.voices.pvc.verification.request(voice.voiceId, {
    files: [fs.createReadStream("/path/to/verification/files.txt")],
});
```

#### Entraîner le PVC

Lancez ensuite le processus d’entraînement. Sa durée dépend de la longueur et du nombre d’échantillons fournis.

```python maxLines=0
elevenlabs.voices.pvc.train(
    voice_id=voice.voice_id,
    # Specify the model the PVC should be trained on
    model_id="eleven_multilingual_v2"
)

# Poll the fine tuning status until it is complete or fails
# This example specifically checks for the eleven_multilingual_v2 model
while True:
    voice_details = elevenlabs.voices.get(voice_id=voice.voice_id)
    fine_tuning_state = None
    if voice_details.fine_tuning and voice_details.fine_tuning.state:
        fine_tuning_state = voice_details.fine_tuning.state.get("eleven_multilingual_v2")

    if fine_tuning_state:
        progress = None
        if voice_details.fine_tuning.progress and voice_details.fine_tuning.progress.get("eleven_multilingual_v2"):
            progress = voice_details.fine_tuning.progress.get("eleven_multilingual_v2")
        print(f"Fine tuning progress: {progress}")

        if fine_tuning_state == "fine_tuned" or fine_tuning_state == "failed":
            print("Fine tuning completed or failed")
            break
    # Wait for 5 seconds before polling again
    time.sleep(5)
```

```typescript maxLines=0
await elevenlabs.voices.pvc.train(voiceId, {
    // Specify the model the PVC should be trained on
    modelId: "eleven_multilingual_v2",
});

// Poll the fine tuning status until it is complete or fails
// This example specifically checks for the eleven_multilingual_v2 model
const interval = setInterval(async () => {
    const { fineTuning } = await elevenlabs.voices.get(voiceId);
    if (!fineTuning) return;

    console.log(`Fine tuning progress: ${fineTuning?.progress?.eleven_multilingual_v2}`);

    if (fineTuning?.state?.eleven_multilingual_v2 === "fine_tuned" || fineTuning?.state?.eleven_multilingual_v2 === "failed") {
        clearInterval(interval);
        console.log("Fine tuning completed or failed");
    }
}, 5000);
```

#### Utiliser la voix nouvellement créée

Une fois le PVC vérifié, vous pouvez l’utiliser comme n’importe quelle autre voix. Consultez le [démarrage rapide de Text to Speech](/docs/fr/eleven-api/quickstart) pour en savoir plus sur l’utilisation d’une voix.

## Étapes suivantes

#### [Clonage de voix instantané](/docs/fr/eleven-api/guides/how-to/voices/instant-voice-cloning)

Créez un clone vocal à partir d’un court échantillon audio, sans entraînement.

#### [Clonage de voix : fonctionnement](/docs/fr/eleven-api/concepts/voice-cloning)

Comprenez les différences techniques entre IVC et PVC, et découvrez lequel choisir.