Voice Cloning

Clone voices and create custom voice models with the Fish Audio Python SDK

Prerequisites

Create a Fish Audio account

Sign up for a free Fish Audio account to get started with our API.

1. Go to fish.audio/auth/signup
2. Fill in your details to create an account, complete steps to verify your account.
3. Log in to your account and navigate to the API section

Get your API key

Once you have an account, you’ll need an API key to authenticate your requests.

1. Log in to your Fish Audio Dashboard
2. Navigate to the API Keys section
3. Click “Create New Key” and give it a descriptive name, set a expiration if desired
4. Copy your key and store it securely

Keep your API key secret! Never commit it to version control or share it publicly.

Instant Voice Cloning

Clone a voice on-the-fly without creating a persistent model using ReferenceAudio:

Synchronous

from fishaudio import FishAudio
from fishaudio.types import ReferenceAudio
from fishaudio.utils import play

client = FishAudio()

# Clone from reference audio
with open("reference_voice.wav", "rb") as f:
    audio = client.tts.convert(
        text="This will sound like the reference voice",
        references=[ReferenceAudio(
            audio=f.read(),
            text="Text spoken in the reference audio"
        )]
    )
play(audio)

import asyncio
from fishaudio import AsyncFishAudio
from fishaudio.types import ReferenceAudio
from fishaudio.utils import play

async def main():
    client = AsyncFishAudio()

    # Clone from reference audio
    with open("reference_voice.wav", "rb") as f:
        audio = await client.tts.convert(
            text="This will sound like the reference voice",
            references=[ReferenceAudio(
                audio=f.read(),
                text="Text spoken in the reference audio"
            )]
        )
    play(audio)

asyncio.run(main())

Instant voice cloning is perfect for one-time use cases. For repeated use of the same voice, create a persistent voice model instead.

Multiple Reference Samples

Improve voice quality by providing multiple reference samples:

Synchronous

from fishaudio import FishAudio
from fishaudio.types import ReferenceAudio
from fishaudio.utils import play

client = FishAudio()

# Load multiple reference samples
references = []
samples = [
    ("sample1.wav", "First sample transcript"),
    ("sample2.wav", "Second sample transcript"),
    ("sample3.wav", "Third sample transcript")
]

for audio_file, transcript in samples:
    with open(audio_file, "rb") as f:
        references.append(ReferenceAudio(
            audio=f.read(),
            text=transcript
        ))

# Generate with multiple references
audio = client.tts.convert(
    text="This voice is trained on multiple samples",
    references=references
)
play(audio)

import asyncio
from fishaudio import AsyncFishAudio
from fishaudio.types import ReferenceAudio
from fishaudio.utils import play

async def main():
    client = AsyncFishAudio()

    # Load multiple reference samples
    references = []
    samples = [
        ("sample1.wav", "First sample transcript"),
        ("sample2.wav", "Second sample transcript"),
        ("sample3.wav", "Third sample transcript")
    ]

    for audio_file, transcript in samples:
        with open(audio_file, "rb") as f:
            references.append(ReferenceAudio(
                audio=f.read(),
                text=transcript
            ))

    # Generate with multiple references
    audio = await client.tts.convert(
        text="This voice is trained on multiple samples",
        references=references
    )
    play(audio)

asyncio.run(main())

Creating Persistent Voice Models

Create a reusable voice model for consistent voice characteristics using voices.create():

Synchronous

from fishaudio import FishAudio

client = FishAudio()

# Prepare voice samples
voice_samples = []
with open("voice1.wav", "rb") as f1:
    voice_samples.append(f1.read())
with open("voice2.wav", "rb") as f2:
    voice_samples.append(f2.read())

# Create voice model
voice = client.voices.create(
    title="My Custom Voice",
    voices=voice_samples,
    description="A custom voice for my project",
    tags=["custom", "english"],
    visibility="private"
)

print(f"Created voice: {voice.id}")

import asyncio
from fishaudio import AsyncFishAudio

async def main():
    client = AsyncFishAudio()

    # Prepare voice samples
    voice_samples = []
    with open("voice1.wav", "rb") as f1:
        voice_samples.append(f1.read())
    with open("voice2.wav", "rb") as f2:
        voice_samples.append(f2.read())

    # Create voice model
    voice = await client.voices.create(
        title="My Custom Voice",
        voices=voice_samples,
        description="A custom voice for my project",
        tags=["custom", "english"],
        visibility="private"
    )

    print(f"Created voice: {voice.id}")

asyncio.run(main())

With Transcripts

Providing transcripts is faster and more accurate than automatic transcription. When you provide transcripts, the system skips running ASR (speech recognition), resulting in better performance and quality:

Synchronous

from fishaudio import FishAudio

client = FishAudio()

# Voice samples with transcripts
samples = [
    ("voice1.wav", "This is the first sample"),
    ("voice2.wav", "This is the second sample"),
    ("voice3.wav", "This is the third sample")
]

voices = []
texts = []

for audio_file, transcript in samples:
    with open(audio_file, "rb") as f:
        voices.append(f.read())
    texts.append(transcript)

# Create voice with transcripts
voice = client.voices.create(
    title="High Quality Voice",
    voices=voices,
    texts=texts,
    description="Voice with accurate transcripts",
    enhance_audio_quality=True
)

print(f"Created voice: {voice.id}")

import asyncio
from fishaudio import AsyncFishAudio

async def main():
    client = AsyncFishAudio()

    # Voice samples with transcripts
    samples = [
        ("voice1.wav", "This is the first sample"),
        ("voice2.wav", "This is the second sample"),
        ("voice3.wav", "This is the third sample")
    ]

    voices = []
    texts = []

    for audio_file, transcript in samples:
        with open(audio_file, "rb") as f:
            voices.append(f.read())
        texts.append(transcript)

    # Create voice with transcripts
    voice = await client.voices.create(
        title="High Quality Voice",
        voices=voices,
        texts=texts,
        description="Voice with accurate transcripts",
        enhance_audio_quality=True
    )

    print(f"Created voice: {voice.id}")

asyncio.run(main())

Audio Quality Enhancement

Enable automatic audio enhancement to clean up noisy reference audio:

voice = client.voices.create(
    title="Enhanced Voice",
    voices=voice_samples,
    enhance_audio_quality=True  # Clean up background noise and normalize levels
)

Audio enhancement helps process noisy or lower-quality reference audio. If your audio is already clean and well-recorded, this may not provide additional benefit.

Managing Voice Models

List Voices

Discover available voices with filtering using voices.list():

Synchronous

from fishaudio import FishAudio

client = FishAudio()

# List all voices
voices = client.voices.list(page_size=20)
print(f"Total voices: {voices.total}")

for voice in voices.items:
    print(f"{voice.title}: {voice.id}")

import asyncio
from fishaudio import AsyncFishAudio

async def main():
    client = AsyncFishAudio()

    # List all voices
    voices = await client.voices.list(page_size=20)
    print(f"Total voices: {voices.total}")

    for voice in voices.items:
        print(f"{voice.title}: {voice.id}")

asyncio.run(main())

Filter by Tags and Language

Synchronous

from fishaudio import FishAudio

client = FishAudio()

# Filter by tags
male_voices = client.voices.list(
    tags=["male", "english"],
    page_size=10
)

# Filter by language
chinese_voices = client.voices.list(
    language="zh",
    page_size=10
)

# Get only your own voices
my_voices = client.voices.list(
    self_only=True,
    page_size=20
)

import asyncio
from fishaudio import AsyncFishAudio

async def main():
    client = AsyncFishAudio()

    # Filter by tags
    male_voices = await client.voices.list(
        tags=["male", "english"],
        page_size=10
    )

    # Filter by language
    chinese_voices = await client.voices.list(
        language="zh",
        page_size=10
    )

    # Get only your own voices
    my_voices = await client.voices.list(
        self_only=True,
        page_size=20
    )

asyncio.run(main())

Get Voice Details

Use voices.get() to retrieve voice details:

Synchronous

from fishaudio import FishAudio

client = FishAudio()

# Get specific voice
voice = client.voices.get("bf322df2096a46f18c579d0baa36f41d")  # Adrian

print(f"Title: {voice.title}")
print(f"Description: {voice.description}")
print(f"Tags: {voice.tags}")
print(f"Languages: {voice.languages}")

import asyncio
from fishaudio import AsyncFishAudio

async def main():
    client = AsyncFishAudio()

    # Get specific voice
    voice = await client.voices.get("bf322df2096a46f18c579d0baa36f41d")  # Adrian

    print(f"Title: {voice.title}")
    print(f"Description: {voice.description}")
    print(f"Tags: {voice.tags}")
    print(f"Languages: {voice.languages}")

asyncio.run(main())

Update Voice Metadata

Update voice information using voices.update():

Synchronous

from fishaudio import FishAudio

client = FishAudio()

# Update voice information
client.voices.update(
    "bf322df2096a46f18c579d0baa36f41d",  # Adrian
    title="Updated Voice Name",
    description="Updated description",
    visibility="public",  # "public", "unlist", or "private"
    tags=["updated", "english", "male"]
)

import asyncio
from fishaudio import AsyncFishAudio

async def main():
    client = AsyncFishAudio()

    # Update voice information
    await client.voices.update(
        "bf322df2096a46f18c579d0baa36f41d",  # Adrian
        title="Updated Voice Name",
        description="Updated description",
        visibility="public",  # "public", "unlist", or "private"
        tags=["updated", "english", "male"]
    )

asyncio.run(main())

Delete Voice

Remove voice models using voices.delete():

Synchronous

from fishaudio import FishAudio

client = FishAudio()

# Delete a voice model
client.voices.delete("bf322df2096a46f18c579d0baa36f41d")  # Adrian
print("Voice deleted successfully")

import asyncio
from fishaudio import AsyncFishAudio

async def main():
    client = AsyncFishAudio()

    # Delete a voice model
    await client.voices.delete("bf322df2096a46f18c579d0baa36f41d")  # Adrian
    print("Voice deleted successfully")

asyncio.run(main())

Deleting a voice is permanent and cannot be undone. Make sure you have backups of any important voice models.

Next Steps

Text-to-Speech

Use cloned voices for speech generation

WebSocket Streaming

Stream audio with custom voices in real-time

Voices API Reference

Complete voice management API documentation

Best Practices

Production tips and optimization strategies

Related Resources

• Voice Types Reference - Voice model data structures
• Audio Formats Guide - Supported audio formats
• Fine-grained Control - Advanced voice customization