> ## Documentation Index
> Fetch the complete documentation index at: https://docs.cartesia.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Pro Voice Clone

> Create a near-exact voice replica, trained on 30+ minutes of your audio

A Professional Voice Clone (PVC) fine-tunes a Cartesia text-to-speech (TTS) model on your audio to produce a near-exact replica of a voice: its accent, speaking style, and audio quality.

We recommend starting with an [Instant Voice Clone](/build-with-cartesia/capability-guides/clone-voices) because it's fast and high quality for most use cases. Use a PVC when the IVC isn't a close enough match and you can supply 30+ minutes of studio-quality audio of a single speaker.

| Feature | Required audio data | Subscription plan needed |
| - | - | - |
| Instant Voice Clone | 10 seconds | Pro plan or above |
| Pro Voice Clone | 30 minutes | Startup plan or above |

## Create a PVC

A PVC closely matches the audio you train it on. Use clean recordings of a single speaker at the volume, pacing, and audio quality you want. The more you provide, the better: 30 minutes is the minimum. Training then takes up to 3 hours.

<Tip>
  **Speed and volume are fixed.** A PVC learns pacing and loudness from your dataset, so the [speed and volume controls](/build-with-cartesia/capability-guides/volume-speed-emotion) have no effect at request time. Set the speed and volume you want in your source audio before training.
</Tip>

### Supported models

New PVCs are automatically trained on all supported model snapshots below:

* `sonic-3.5-2026-05-04`
* `sonic-3.6-2026-08-27`

The `model_id` field in [Create Fine-tune](/api-reference/fine-tunes/create) is deprecated and ignored.

### Recording tips

Recording 30 minutes of usable audio takes planning. With that much audio the model learns the voice itself: accent, timbre, and the small habits that make it recognizable. Vary the emotion across the dataset so the clone isn't locked to one register.

A PVC is trained on one language at a time, so record a separate dataset for each language you need.

* Cover a realistic range of emotional registers: neutral, warm, upbeat, concerned, reassuring
* Approve a test read before recording the full dataset
* Take breaks. A tired voice drifts, and the drift ends up in the clone

The basics apply to every take:

* **One speaker, no background noise.** A quiet room, no music, no echo off bare walls.
* **Speak the way you want the clone to speak.** Tone, accent, pacing, and energy all carry over.
* **Speak naturally, not like an announcer.** Over-enunciation and theatrical delivery make the clone sound less conversational.
* **Avoid long pauses.** The clone mimics your pacing, including the silence between sentences.
* **Record in a language the speaker actually speaks.** Each clone is built from one language.

At the microphone:

<table className="m-0 min-w-full w-full max-w-none table [&_td]:min-w-[150px] [&_th]:text-left">
  <colgroup>
    <col width="50%" />

    <col width="50%" />
  </colgroup>

  <thead>
    <tr><th>Do</th><th>Don't</th></tr>
  </thead>

  <tbody>
    <tr><td>Speak slightly off to the side of the mic, about a 45° angle</td><td>Speak straight into it - this causes plosives (popping on your p's and b's)</td></tr>
    <tr><td>Keep a steady distance and volume the whole time</td><td>Lean in and out, or let your volume drift up and down - this can cause inconsistency in the clone's volume</td></tr>
    <tr><td>Record raw, with all effects and filters turned off</td><td>Add noise reduction, echo, or EQ tweaks - this can cause unnatural artefacts in the clone</td></tr>
    <tr><td>Stay hydrated</td><td>Record with a dry mouth - this can cause subtle mouth noises to be picked up by the mic</td></tr>
  </tbody>
</table>

**Get the delivery right.** Redo takes until you're happy with the delivery. Editing can tidy up silences, but it can't fix a flat take.

<Accordion title="Example delivery brief">
  Decide how the clone should sound before you record, and write it down. Adapt this for your own brand.

  **Voice Quality**

  <div className="flex flex-wrap items-center gap-2 my-3">
    <Badge color="green" shape="pill" stroke="true">medium pitch</Badge>
    <Badge color="green" shape="pill" stroke="true">competent</Badge>
    <Badge color="green" shape="pill" stroke="true">professional</Badge>
    <Badge color="green" shape="pill" stroke="true">friendly</Badge>
    <Badge color="green" shape="pill" stroke="true">approachable</Badge>
  </div>

  **Voice Delivery**

  <div className="flex flex-wrap items-center gap-2 my-3">
    <Badge color="green" shape="pill" stroke="true">warm</Badge>
    <Badge color="green" shape="pill" stroke="true">clear</Badge>
    <Badge color="green" shape="pill" stroke="true">conversational</Badge>
    <Badge color="green" shape="pill" stroke="true">upbeat</Badge>
    <Badge color="green" shape="pill" stroke="true">lively</Badge>
  </div>

  **Goal:** Sound like a genuine, empathetic voice, not a scripted agent.

  **Delivery notes**

  | Marker | Direction |
  | - | - |
  | `[pause]` | A thinking pause of one to two seconds. Don't rush it |
  | `[small laugh]`, `[gentle laugh]` | Very subtle. A smile in the voice, not full laughter |
  | `[smiling tone]` | Slight uplift at the end of the phrase, friendly but not casual |
  | Confirmation questions | Slight upward inflection. "Does that work for you?" should sound genuinely inquisitive |
  | Spelled-out names | Clear and measured. For `D-E-B-O-R-A-H`, pause briefly between letters |
  | Numbers and times | Conversational rhythm. Read `415-555-9900` as "four-one-five" \[short pause] "five-five-five" \[short pause] "nine-nine-zero-zero" |
</Accordion>

<Accordion title="What a pro voice clone dataset should cover">
  Map the conversations your agent will actually have and write transcripts for each. Mix scripted lines with semi-improvised responses, so the dataset captures real phrasing, breaths, and transitions. For example, a customer service dataset should include:

  * Opening greetings, in several variations
  * Scheduling and confirmations
  * Spelling, emails, and alphanumerics
  * Errors and empathy
  * Misunderstanding and clarification
  * Times, dates, and durations
  * Natural speech patterns and filler
  * Closings
</Accordion>

### In the dashboard

Open the [Pro Voice Clone](https://play.cartesia.ai/pro-voice-cloning) page. From here you create a PVC and track the status of your existing clones. Follow the steps on screen to provide audio data, start the training, and listen to the voices it creates.

### With the API

Create PVCs programmatically using the following endpoints:

1. [Create a dataset](/api-reference/datasets/create) to hold your data
2. [Upload files](/api-reference/datasets/upload-file) to the dataset
3. [Create a fine-tune](/api-reference/fine-tunes/create) from the dataset
4. [List the voices](/api-reference/fine-tunes/list-voices) the fine-tune produced

> **Prerequisites**
>
> 1. You have a **Cartesia API key** (export it as `CARTESIA_API_KEY`).
> 2. You have a folder called `samples/` with one or more `.wav` files.

```python expandable theme={null}
"""
End-to-end Pro Voice Cloning example.

Steps
-----
1. Create a dataset.
2. Upload audio files from samples/ to the dataset.
3. Kick off a fine-tune from that dataset.
4. Poll until fine-tune is completed.
5. Get the voices produced by the fine-tune.
"""

import os
import time
from pathlib import Path

import requests

API_BASE = "https://api.cartesia.ai"
API_HEADERS = {
    "Cartesia-Version": "2026-08-14",
    "Authorization": f"Bearer {os.environ['CARTESIA_API_KEY']}",
}


def create_dataset(name: str, description: str) -> str:
    """POST /datasets → dataset id."""
    res = requests.post(
        f"{API_BASE}/datasets",
        headers=API_HEADERS,
        json={"name": name, "description": description},
    )
    res.raise_for_status()
    return res.json()["id"]


def upload_file_to_dataset(dataset_id: str, path: Path) -> None:
    """POST /datasets/{dataset_id}/files (multipart/form-data)."""
    with path.open("rb") as fp:
        res = requests.post(
            f"{API_BASE}/datasets/{dataset_id}/files",
            headers=API_HEADERS,
            files={"file": fp, "purpose": (None, "fine_tune")},
        )
    res.raise_for_status()


def create_fine_tune(dataset_id: str, *, name: str, language: str) -> str:
    """POST /fine-tunes → fine-tune id."""
    body = {
        "name": name,
        "description": "Pro Voice Clone demo",
        "language": language,
        "dataset": dataset_id,
    }
    res = requests.post(f"{API_BASE}/fine-tunes", headers=API_HEADERS, json=body, timeout=60)
    res.raise_for_status()
    return res.json()["id"]


def wait_for_fine_tune(ft_id: str, every: float = 10.0) -> None:
    """Poll GET /fine-tunes/{id} until status == completed."""
    start = time.monotonic()
    while True:
        res = requests.get(f"{API_BASE}/fine-tunes/{ft_id}", headers=API_HEADERS)
        res.raise_for_status()
        status = res.json()["status"]
        print(f"fine-tune {ft_id} -> {status}. Elapsed: {time.monotonic() - start:.0f}s")
        if status == "completed":
            return
        if status == "failed":
            raise RuntimeError(f"fine-tune ended with status={status}")
        time.sleep(every)


def list_voices(ft_id: str) -> list[dict]:
    """GET /fine-tunes/{id}/voices → list of voices."""
    res = requests.get(f"{API_BASE}/fine-tunes/{ft_id}/voices", headers=API_HEADERS)
    res.raise_for_status()
    return res.json()["data"]


if __name__ == "__main__":
    # Create the dataset
    DATASET_ID = create_dataset("PVC demo", "Samples for a Pro Voice Clone")
    print("Created dataset:", DATASET_ID)

    # Upload .wav files to the dataset
    for wav_path in Path("samples").glob("*.wav"):
        upload_file_to_dataset(DATASET_ID, wav_path)
        print(f"Uploaded {wav_path.name} to dataset {DATASET_ID}")

    # Kick off the fine-tune
    FINE_TUNE_ID = create_fine_tune(
        DATASET_ID,
        name="PVC demo",
        language="en",
    )
    print(f"Started fine-tune: {FINE_TUNE_ID}")

    # Wait for training to finish
    wait_for_fine_tune(FINE_TUNE_ID)
    print("Fine-tune completed!")

    # Fetch the voices created by the fine-tune
    voices = list_voices(FINE_TUNE_ID)
    print("Voices IDs:")
    for voice in voices:
        print(voice["id"])
```

## Use a PVC in Text-to-Speech

<Tip>
  A Pro Voice Clone is trained for every [supported model](#supported-models). As Cartesia releases newer models, we automatically make your voice available on them, so it keeps working when you upgrade.
</Tip>

In your text-to-speech API request, set [`model_id`](/api-reference/tts/bytes#body-model-id) to one of the voice's supported models, returned in the [`fine_tunes.public_model_id`](/api-reference/voices/get#response-fine-tunes-items-public-model-id) field of the [Get Voice](/api-reference/voices/get) response.

You can't use a PVC with [`sonic-preview`](/build-with-cartesia/tts-models/latest#continuous-updates-recommended). It's a beta model that changes without notice, so a voice trained against one snapshot isn't compatible with the next.

Passing `sonic-preview` or an unsupported `model_id` returns HTTP `400` with a `voice_model_mismatch` error:

```json theme={null}
{
  "error_code": "voice_model_mismatch",
  "title": "Invalid voice",
  "message": "The requested voice is not compatible with the requested model. Switch to one of these compatible models: sonic-3.5-2026-05-04, sonic-3.6-2026-08-27.",
  "request_id": "550e8400-e29b-41d4-a716-446655440000"
}
```

## FAQs

<AccordionGroup>
  <Accordion title="Should I use an IVC or a PVC?">
    For most use cases, start with an IVC: it's fast, high quality, and needs only 10 seconds of audio. Choose a PVC to clone character voices, preserve rare accents, or match a specific tone and pacing.
  </Accordion>

  <Accordion title="How do I find my PVCs?">
    Find your PVCs from the Cartesia dashboard or the API. In the dashboard, go to [My Voices](https://play.cartesia.ai/voices?category=my-voices) in the Voice Library and look for the **PRO** badge. From the API, call [List Voices](/api-reference/voices/list) with `is_owner=true` and filter for voices where `is_pro=true`.
  </Accordion>

  <Accordion title="How many PVC fine tunes can I create?">
    The number of PVC fine tunes you can create depends on your subscription plan:

    | Plan | PVC slots |
    | - | - |
    | Free | Not available |
    | Pro | Not available |
    | Startup | 2 |
    | Scale | 4 |
    | Enterprise | Custom |

    To find how many PVC fine tunes you currently have, open the [Pro Voice Clone](https://play.cartesia.ai/pro-voice-cloning) page in the dashboard. The **Limit** line shows how many fine tunes you've created against your plan's total.
  </Accordion>

  <Accordion title="What if I've reached my plan's slot limit?">
    Your existing PVCs keep working. To train a new one, delete a fine-tune you no longer need from the [Pro Voice Clone](https://play.cartesia.ai/pro-voice-cloning) page or the [Delete Fine Tune](/api-reference/fine-tunes/delete) endpoint, or upgrade your plan for more slots.
  </Accordion>

  <Accordion title="Can I buy more slots without upgrading my plan?">
    Slots aren't sold separately. To make room for a new PVC, free up a slot by deleting a fine-tune you no longer need, or upgrade your plan for more slots.
  </Accordion>

  <Accordion title="What happens to my PVCs if I downgrade or cancel my plan?">
    Your existing PVCs keep working, even if you're over your new plan's limit. You can't train a new one until you're back under the limit.
  </Accordion>

  <Accordion title="Do I need to migrate my PVC when Cartesia releases a new model?">
    No. We automatically adapt your PVC to new TTS models as they're released, so it keeps working when you switch `model_id`. These adapted versions don't count against your plan's slots.
  </Accordion>
</AccordionGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.