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

# Quickstart della Clonazione Vocale Professionale

Questa guida ti mostrerà come creare un Clone Vocale Professionale (PVC) usando l'API PVC. Per creare un PVC tramite la dashboard, consulta la guida al prodotto [Clone Vocale Professionale](/docs/it/eleven-creative/voices/voice-cloning/professional-voice-cloning).

> **Info**
>
> Per creare un PVC devi avere il [piano Creator o superiore](https://elevenlabs.io/pricing).

Per una spiegazione approfondita del funzionamento di IVC e PVC e di quando scegliere ciascuno, consulta [Clonazione vocale: come funziona](/docs/it/eleven-api/concepts/voice-cloning).

> **Warning**
>
> Se non sei sicuro di ciò che è consentito dal punto di vista legale, consulta i [Termini di servizio](https://elevenlabs.io/terms-of-use) e le nostre informazioni sulla [sicurezza dell'IA](https://elevenlabs.io/safety) per maggiori dettagli.

Creare un PVC tramite l'API richiede molti più passaggi rispetto alla creazione di un Clone Vocale Istantaneo. Questo perché i PVC sono più complessi e richiedono più dati e perfezionamento per creare un clone di alta qualità.

## Usare l'API Clone Vocale Professionale

> **Note**
>
> Questa guida presuppone che tu abbia [configurato la chiave API e l'SDK](/docs/it/eleven-api/quickstart). Completa
> prima il quickstart, se non l'hai ancora fatto.

#### Crea una voce PVC

Crea un nuovo file denominato `example.py` o `example.mts`, a seconda del linguaggio scelto, e aggiungi il seguente codice per creare una voce 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);
```

#### Carica i file audio

Ora caricheremo i file audio di esempio che verranno usati per addestrare il PVC. Consulta la sezione [Suggerimenti e consigli](/docs/it/eleven-creative/voices/voice-cloning/professional-voice-cloning#tips-and-suggestions) della guida al prodotto PVC per ulteriori informazioni su come ottenere i migliori risultati dai tuoi file 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")],
})
```

#### Avvia la separazione dei parlanti

Questo passaggio tenterà di separare i file audio in singoli parlanti. È necessario se carichi audio con più parlanti.

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

#### Recupera l'audio dei parlanti

> **Warning**
>
> Poiché il passaggio precedente richiederà del tempo per essere completato, il passaggio seguente deve essere eseguito in un processo separato dopo il completamento di quello precedente.

Una volta completata la separazione dei parlanti, avrai un elenco di parlanti per ogni campione. Nel caso di campioni con più parlanti, dovrai scegliere quello da usare per il PVC. Per identificare il parlante, puoi recuperare l'audio di ciascuno e ascoltarlo.

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

#### Aggiorna i campioni con gli ID dei parlanti

Una volta completata la separazione dei parlanti, puoi aggiornare i campioni per selezionare il parlante da usare per il 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],
})
```

Ripeti questa procedura per ogni campione con più parlanti.

#### Verifica il PVC

Prima di iniziare l'addestramento, è necessario un passaggio di verifica per assicurarsi che tu abbia l'autorizzazione a usare la voce. Per prima cosa, richiedi il CAPTCHA di verifica.

```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'immagine contiene diverse righe di testo che il proprietario della voce dovrà leggere ad alta voce e registrare. Al termine, invia la registrazione per verificare l'identità del proprietario della voce.

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

#### (Facoltativo) Richiedi una verifica manuale

Se non riesci a verificare il CAPTCHA, puoi richiedere una verifica manuale. Tieni presente che l'elaborazione richiederà più tempo.

Usala soltanto se i passaggi di verifica precedenti non sono riusciti o non sono possibili, ad esempio se il proprietario della voce è ipovedente.

Per l'elenco dei file richiesti per la verifica manuale, contatta l'assistenza, poiché ogni caso può essere unico.

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

#### Addestra il PVC

Ora avvia il processo di addestramento. Il completamento richiederà del tempo in base alla durata e al numero di campioni forniti.

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

#### Usa la voce appena creata

Dopo la verifica del PVC, puoi usarlo come qualsiasi altra voce. Consulta il [quickstart di Text to Speech](/docs/it/eleven-api/quickstart) per ulteriori informazioni su come usare una voce.

## Passaggi successivi

#### [Clonazione vocale istantanea](/docs/it/eleven-api/guides/how-to/voices/instant-voice-cloning)

Crea un clone vocale da un breve campione audio senza addestramento.

#### [Clonazione vocale: come funziona](/docs/it/eleven-api/concepts/voice-cloning)

Scopri le differenze tecniche tra IVC e PVC e quando scegliere ciascuno.