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

# Guia de início rápido da Clonagem de Voz Profissional

Este guia mostra como criar um Clone de Voz Profissional (PVC) usando a API de PVC. Para criar um PVC pelo painel, consulte o guia do produto [Clone de Voz Profissional](/docs/pt/eleven-creative/voices/voice-cloning/professional-voice-cloning).

> **Info**
>
> Para criar um PVC, você precisa estar no [plano Creator ou superior](https://elevenlabs.io/pricing).

Para uma explicação detalhada de como IVC e PVC funcionam internamente e quando escolher cada um, consulte [Clonagem de voz: como funciona](/docs/pt/eleven-api/concepts/voice-cloning).

> **Warning**
>
> Se você não tiver certeza sobre o que é permitido do ponto de vista legal, consulte os [Termos de Serviço](https://elevenlabs.io/terms-of-use) e nossas [informações sobre segurança de IA](https://elevenlabs.io/safety) para saber mais.

Criar um PVC pela API envolve consideravelmente mais etapas do que criar um Clone de Voz Instantâneo. Isso acontece porque os PVCs são mais complexos e exigem mais dados e ajustes para criar um clone de alta qualidade.

## Como usar a API de Clone de Voz Profissional

> **Note**
>
> Este guia pressupõe que você já [configurou sua chave de API e o SDK](/docs/pt/eleven-api/quickstart). Conclua
> o guia de início rápido primeiro, caso ainda não tenha feito isso.

#### Criar uma voz PVC

Crie um novo arquivo chamado `example.py` ou `example.mts`, dependendo da linguagem escolhida, e adicione o código a seguir para criar uma voz 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);
```

#### Enviar arquivos de áudio

Em seguida, envie os arquivos de amostra de áudio que serão usados para treinar o PVC. Consulte a seção [Dicas e sugestões](/docs/pt/eleven-creative/voices/voice-cloning/professional-voice-cloning#tips-and-suggestions) do guia do produto PVC para saber mais sobre como obter os melhores resultados com seus arquivos de áudio.

```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")],
})
```

#### Iniciar a separação de locutores

Esta etapa tentará separar os arquivos de áudio em locutores individuais. Isso é necessário se você estiver enviando áudio com vários locutores.

```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);
```

#### Recuperar o áudio dos locutores

> **Warning**
>
> Como a etapa anterior levará algum tempo para ser concluída, a próxima etapa deve ser executada em um processo separado após a conclusão da etapa anterior.

Quando a separação de locutores estiver concluída, você terá uma lista de locutores para cada amostra. No caso de amostras com vários locutores, será preciso escolher o locutor que deseja usar para o PVC. Para identificar o locutor, você pode recuperar o áudio de cada um e ouvi-los.

```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);
            }
        }
    }
}
```

#### Atualizar amostras com IDs de locutores

Quando a separação de locutores estiver concluída, você poderá atualizar as amostras para selecionar qual locutor deseja usar para o 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],
})
```

Repita esse processo para cada amostra com vários locutores.

#### Verificar o PVC

Antes que o treinamento possa começar, é necessária uma etapa de verificação para garantir que você tem permissão para usar a voz. Primeiro, solicite o CAPTCHA de verificação.

```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);
```

A imagem contém várias linhas de texto que o proprietário da voz precisará ler em voz alta e gravar. Depois disso, envie a gravação para verificar a identidade do proprietário da voz.

```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"),
})
```

#### (Opcional) Solicitar verificação manual

Se não for possível verificar o CAPTCHA, você poderá solicitar uma verificação manual. Observe que o processamento será mais demorado.

Use este recurso somente se as etapas de verificação anteriores falharam ou não são possíveis, por exemplo, se o proprietário da voz tiver deficiência visual.

Para obter uma lista dos arquivos necessários para a verificação manual, entre em contato com o suporte, pois cada caso pode ser único.

```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")],
});
```

#### Treinar o PVC

Em seguida, inicie o processo de treinamento. Isso levará algum tempo para ser concluído, dependendo da duração e do número de amostras fornecidas.

```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);
```

#### Usar a voz recém-criada

Depois que o PVC for verificado, você poderá usá-lo da mesma forma que qualquer outra voz. Consulte o [guia de início rápido de Text to Speech](/docs/pt/eleven-api/quickstart) para saber mais sobre como usar uma voz.

## Próximas etapas

#### [Clonagem de voz instantânea](/docs/pt/eleven-api/guides/how-to/voices/instant-voice-cloning)

Crie um clone de voz a partir de uma amostra curta de áudio, sem treinamento.

#### [Clonagem de voz: como funciona](/docs/pt/eleven-api/concepts/voice-cloning)

Entenda as diferenças técnicas entre IVC e PVC e quando escolher cada um.