Skip to main content

​
Overview

Audio Isolation removes background noise from audio files, producing clean speech output. This is perfect for cleaning up recordings before voice cloning, dubbing, or general audio processing.

​
Basic Isolation

Remove background noise from an audio file: 
from elevenlabs.client import ElevenLabs

client = ElevenLabs(api_key="YOUR_API_KEY")

audio = client.audio_isolation.convert(
    audio=open("noisy_audio.mp3", "rb")
)

# Save the cleaned audio
with open("clean_audio.mp3", "wb") as f:
    for chunk in audio:
        f.write(chunk)

​
Streaming Isolation

Stream the cleaned audio in real-time: 
from elevenlabs.client import ElevenLabs

client = ElevenLabs(api_key="YOUR_API_KEY")

audio_stream = client.audio_isolation.stream(
    audio=open("noisy_recording.mp3", "rb")
)

# Process the cleaned audio stream
with open("cleaned_output.mp3", "wb") as f:
    for chunk in audio_stream:
        f.write(chunk)

​
Parameters

​
audio
File
required
The audio file to process and remove background noise from.
​
file_format
string
The format of input audio. Options:
  • pcm_s16le_16 - 16-bit PCM at 16kHz, mono, little-endian (lower latency)
  • other - Any other audio format (default)
​
preview_b_64
string
Optional preview image base64 for tracking this generation.

​
PCM Input for Lower Latency

Use PCM format for the lowest latency: 
# Input must be 16-bit PCM at 16kHz, single channel (mono), little-endian
audio = client.audio_isolation.convert(
    audio=open("input.pcm", "rb"),
    file_format="pcm_s16le_16"
)

with open("output.pcm", "wb") as f:
    for chunk in audio:
        f.write(chunk)

​
Batch Processing

Process multiple files: 
import os
from elevenlabs.client import ElevenLabs

client = ElevenLabs(api_key="YOUR_API_KEY")

input_dir = "noisy_recordings/"
output_dir = "clean_recordings/"

os.makedirs(output_dir, exist_ok=True)

for filename in os.listdir(input_dir):
    if filename.endswith((".mp3", ".wav", ".m4a")):
        print(f"Processing {filename}...")
        
        input_path = os.path.join(input_dir, filename)
        output_path = os.path.join(output_dir, f"clean_{filename}")
        
        audio = client.audio_isolation.convert(
            audio=open(input_path, "rb")
        )
        
        with open(output_path, "wb") as f:
            for chunk in audio:
                f.write(chunk)
        
        print(f"Saved to {output_path}")

print("Batch processing complete!")

​
Async Processing

Process audio asynchronously: 
import asyncio
from elevenlabs.client import AsyncElevenLabs

async def clean_audio(filepath: str, output_path: str):
    client = AsyncElevenLabs(api_key="YOUR_API_KEY")
    
    audio = await client.audio_isolation.convert(
        audio=open(filepath, "rb")
    )
    
    with open(output_path, "wb") as f:
        async for chunk in audio:
            f.write(chunk)
    
    print(f"Cleaned: {output_path}")

asyncio.run(clean_audio("noisy.mp3", "clean.mp3"))

​
Parallel Processing

Process multiple files concurrently: 
import asyncio
from elevenlabs.client import AsyncElevenLabs

async def clean_audio_file(client, input_path, output_path):
    """Clean a single audio file"""
    audio = await client.audio_isolation.convert(
        audio=open(input_path, "rb")
    )
    
    with open(output_path, "wb") as f:
        async for chunk in audio:
            f.write(chunk)
    
    return output_path

async def clean_multiple_files(file_pairs):
    """Clean multiple files in parallel"""
    client = AsyncElevenLabs(api_key="YOUR_API_KEY")
    
    tasks = [
        clean_audio_file(client, input_path, output_path)
        for input_path, output_path in file_pairs
    ]
    
    results = await asyncio.gather(*tasks)
    return results

# Process 5 files concurrently
file_pairs = [
    ("noisy1.mp3", "clean1.mp3"),
    ("noisy2.mp3", "clean2.mp3"),
    ("noisy3.mp3", "clean3.mp3"),
    ("noisy4.mp3", "clean4.mp3"),
    ("noisy5.mp3", "clean5.mp3"),
]

results = asyncio.run(clean_multiple_files(file_pairs))
print(f"Processed {len(results)} files")

​
Integration with Voice Cloning

Clean audio before voice cloning: 
from elevenlabs.client import ElevenLabs
import os

client = ElevenLabs(api_key="YOUR_API_KEY")

# Step 1: Clean the audio samples
noisy_samples = ["sample1.mp3", "sample2.mp3", "sample3.mp3"]
clean_samples = []

for i, sample in enumerate(noisy_samples):
    print(f"Cleaning {sample}...")
    
    audio = client.audio_isolation.convert(
        audio=open(sample, "rb")
    )
    
    clean_path = f"clean_sample_{i}.mp3"
    with open(clean_path, "wb") as f:
        for chunk in audio:
            f.write(chunk)
    
    clean_samples.append(clean_path)

# Step 2: Create voice clone with cleaned samples
voice = client.voices.ivc.create(
    name="Clean Voice Clone",
    description="Voice clone from cleaned audio samples",
    files=clean_samples
)

print(f"Voice cloned with ID: {voice.voice_id}")

# Cleanup temporary files
for sample in clean_samples:
    os.remove(sample)

​
With Speech-to-Speech

Clean input before voice conversion: 
from elevenlabs.client import ElevenLabs

client = ElevenLabs(api_key="YOUR_API_KEY")

# Option 1: Clean first, then convert
audio_cleaned = client.audio_isolation.convert(
    audio=open("noisy_input.mp3", "rb")
)

# Save temporarily
with open("temp_clean.mp3", "wb") as f:
    for chunk in audio_cleaned:
        f.write(chunk)

# Then convert voice
audio_converted = client.speech_to_speech.convert(
    voice_id="JBFqnCBsd6RMkjVDRZzb",
    audio=open("temp_clean.mp3", "rb"),
    model_id="eleven_multilingual_sts_v2"
)

# Option 2: Use built-in noise removal in speech-to-speech
audio_converted = client.speech_to_speech.convert(
    voice_id="JBFqnCBsd6RMkjVDRZzb",
    audio=open("noisy_input.mp3", "rb"),
    model_id="eleven_multilingual_sts_v2",
    remove_background_noise=True  # Built-in cleaning
)

​
Use Cases

Voice Cloning Prep

Clean samples before creating voice clones

Podcast Editing

Remove background noise from recordings

Interview Cleanup

Improve audio quality of interviews

Content Creation

Clean audio for videos and content

​
Best Practices

  • Audio isolation works best on recordings with clear speech
  • For voice cloning, always clean samples first for better results
  • Use PCM input format for real-time or low-latency applications
  • Process files in parallel for large batches
  • Keep original files as backups
Audio isolation is designed for speech. It may not work well for music or non-speech audio where background elements are important.
If the input audio does not contain background noise, using audio isolation may actually reduce quality. Only use this feature when background noise is present.

​
Output Format

The output audio maintains the same format as the input (e.g., MP3 in, MP3 out). The audio isolation process:
  • Preserves speech frequencies
  • Removes background noise
  • Maintains original sample rate and format
  • Keeps speech quality intact

​
Error Handling

from elevenlabs.client import ElevenLabs

client = ElevenLabs(api_key="YOUR_API_KEY")

try:
    audio = client.audio_isolation.convert(
        audio=open("noisy.mp3", "rb")
    )
    
    with open("clean.mp3", "wb") as f:
        for chunk in audio:
            f.write(chunk)
    
    print("Audio cleaned successfully")
    
except FileNotFoundError:
    print("Input file not found")
except Exception as e:
    print(f"Error during audio isolation: {e}")

Build docs developers (and LLMs) love

Get started for freeTalk to us