Get Started with ElevenLabs

ElevenLabs is a leading voice AI platform that provides realistic text-to-speech, voice cloning, and dubbing capabilities. By combining Cerebras Inference’s lightning-fast LLM responses with ElevenLabs’ natural-sounding voice synthesis, you can build responsive voice agents and conversational AI applications. This guide will walk you through integrating Cerebras models with ElevenLabs to create a complete voice AI pipeline.

Prerequisites

Before you begin, ensure you have:

Cerebras API Key - Get a free API key here.
ElevenLabs API Key - Visit ElevenLabs and create an account. Navigate to your profile settings to generate an API key.
Python 3.10 or higher - Required for running the integration code.

Configure ElevenLabs Integration

Install required dependencies

Install the necessary Python packages for both Cerebras Inference and ElevenLabs:

pip install openai elevenlabs

The openai package provides the client for Cerebras Inference (OpenAI-compatible), and elevenlabs is the official ElevenLabs SDK for voice synthesis.

Audio playback requirement: To play audio files, you may need to install FFmpeg:

macOS: brew install ffmpeg
Windows: Download from ffmpeg.org or use choco install ffmpeg
Linux: sudo apt install ffmpeg (Ubuntu/Debian) or sudo yum install ffmpeg (CentOS/RHEL)

Configure environment variables

Create a .env file in your project directory to securely store your API keys:

CEREBRAS_API_KEY=your-cerebras-api-key-here
ELEVENLABS_API_KEY=your-elevenlabs-api-key-here

Alternatively, you can set these as environment variables in your shell:

export CEREBRAS_API_KEY="your-cerebras-api-key-here"
export ELEVENLABS_API_KEY="your-elevenlabs-api-key-here"

Initialize the Cerebras client

Set up the Cerebras client using the OpenAI-compatible interface. The integration header helps us track and optimize this integration:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("CEREBRAS_API_KEY"),
    base_url="https://api.cerebras.ai/v1",
    default_headers={"X-Cerebras-3rd-Party-Integration": "elevenlabs"}
)

Create a basic text-to-speech pipeline

Now let’s create a complete pipeline that generates text with Cerebras and converts it to speech with ElevenLabs. This example demonstrates the power of combining Cerebras’s fast inference with ElevenLabs’s natural voice synthesis:

import os
from openai import OpenAI
from elevenlabs.client import ElevenLabs
from elevenlabs.play import play

# Initialize Cerebras client
cerebras_client = OpenAI(
    api_key=os.getenv("CEREBRAS_API_KEY"),
    base_url="https://api.cerebras.ai/v1",
    default_headers={"X-Cerebras-3rd-Party-Integration": "elevenlabs"}
)

# Initialize ElevenLabs client
elevenlabs_client = ElevenLabs(
    api_key=os.getenv("ELEVENLABS_API_KEY")
)

def generate_and_speak(prompt, voice_id="21m00Tcm4TlvDq8ikWAM"):
    """
    Generate text response using Cerebras and convert to speech with ElevenLabs.
    
    Args:
        prompt: User input text
        voice_id: ElevenLabs voice ID (default is Rachel)
    """
    # Generate text response with Cerebras
    response = cerebras_client.chat.completions.create(
        model="gpt-oss-120b",
        messages=[
            {"role": "system", "content": "You are a helpful assistant. Keep responses concise and natural for voice output."},
            {"role": "user", "content": prompt}
        ],
        max_completion_tokens=150,
        temperature=0.7,
        extra_headers={
            "X-Cerebras-3rd-Party-Integration": "elevenlabs"
        }
    )
    
    text_response = response.choices[0].message.content
    print(f"Generated text: {text_response}")
    
    # Convert to speech with ElevenLabs
    audio = elevenlabs_client.text_to_speech.convert(
        text=text_response,
        voice_id=voice_id,
        model_id="eleven_multilingual_v2",
        output_format="mp3_44100_128"
    )
    
    # Play the audio
    play(audio)
    
    # And save to a file
    with open("output.mp3", "wb") as f:
        for chunk in audio:
            f.write(chunk)
    
    return text_response

# Example usage
if __name__ == "__main__":
    generate_and_speak("Tell me an interesting fact about space exploration.")

Build a conversational voice agent

For a more advanced use case, here’s how to build a multi-turn conversational agent that maintains context across multiple interactions:

import os
from openai import OpenAI
from elevenlabs.client import ElevenLabs
from elevenlabs.play import play

# Initialize Cerebras client
cerebras_client = OpenAI(
    api_key=os.getenv("CEREBRAS_API_KEY"),
    base_url="https://api.cerebras.ai/v1",
    default_headers={"X-Cerebras-3rd-Party-Integration": "elevenlabs"}
)

# Initialize ElevenLabs client
elevenlabs_client = ElevenLabs(
    api_key=os.getenv("ELEVENLABS_API_KEY")
)

class VoiceAgent:
    def __init__(self, system_prompt, voice_id="21m00Tcm4TlvDq8ikWAM"):
        self.conversation_history = [
            {"role": "system", "content": system_prompt}
        ]
        self.voice_id = voice_id
    
    def chat(self, user_input):
        """Process user input and generate voice response."""
        # Add user message to history
        self.conversation_history.append({
            "role": "user",
            "content": user_input
        })
        
        # Generate response with Cerebras
        response = cerebras_client.chat.completions.create(
            model="gpt-oss-120b",
            messages=self.conversation_history,
            max_completion_tokens=200,
            temperature=0.8,
            extra_headers={
                "X-Cerebras-3rd-Party-Integration": "elevenlabs"
            }
        )
        
        assistant_message = response.choices[0].message.content
        
        # Add assistant response to history
        self.conversation_history.append({
            "role": "assistant",
            "content": assistant_message
        })
        
        print(f"Assistant: {assistant_message}")
        
        # Convert to speech using updated ElevenLabs API method
        audio = elevenlabs_client.text_to_speech.convert(
            text=assistant_message,
            voice_id=self.voice_id,
            model_id="eleven_multilingual_v2",  # Use current supported free tier model
            output_format="mp3_44100_128"
        )
        
        # Play audio
        play(audio)
        
        return assistant_message

# Example: Customer service agent
agent = VoiceAgent(
    system_prompt="You are a friendly customer service representative. Be helpful, concise, and professional.",
    voice_id="21m00Tcm4TlvDq8ikWAM"  # Rachel voice
)

# Simulate conversation
agent.chat("Hi, I need help with my order.")
agent.chat("My order number is 12345.")
agent.chat("When will it arrive?")

This voice agent maintains conversation context and provides natural, spoken responses using Cerebras’s fast inference and ElevenLabs’s voice synthesis.

Stream responses for lower latency

For even faster response times, you can stream the Cerebras output and generate speech in chunks. Streaming provides the lowest possible latency by starting audio playback as soon as content is ready:

import os
from openai import OpenAI
from elevenlabs.client import ElevenLabs
from elevenlabs.play import play  # Use play for audio playback

cerebras_client = OpenAI(
    api_key=os.getenv("CEREBRAS_API_KEY"),
    base_url="https://api.cerebras.ai/v1",
    default_headers={"X-Cerebras-3rd-Party-Integration": "elevenlabs"}
)

elevenlabs_client = ElevenLabs(
    api_key=os.getenv("ELEVENLABS_API_KEY")
)

def streaming_voice_response(prompt):
    """Generate and speak response with streaming for minimal latency."""
    # Stream text from Cerebras
    response_stream = cerebras_client.chat.completions.create(
        model="gpt-oss-120b",
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": prompt}
        ],
        stream=True,
        max_completion_tokens=200,
        extra_headers={
            "X-Cerebras-3rd-Party-Integration": "elevenlabs"
        }
    )
    
    full_response = ""
    for chunk in response_stream:
        if chunk.choices[0].delta.content:
            content = chunk.choices[0].delta.content
            full_response += content
            print(content, end="", flush=True)
    print()  # Newline after text stream
    
    # Generate audio from ElevenLabs
    audio = elevenlabs_client.text_to_speech.convert(
        text=full_response,
        voice_id="21m00Tcm4TlvDq8ikWAM",
        model_id="eleven_multilingual_v2",
        output_format="mp3_44100_128"
    )
    
    # Play audio
    play(audio)
    
    return full_response

# Example usage
streaming_voice_response("Explain quantum computing in simple terms.")

Voice Selection

ElevenLabs offers a variety of pre-made voices. Here are some popular options:

Rachel (21m00Tcm4TlvDq8ikWAM) - Calm, professional female voice
Adam (pNInz6obpgDQGcFmaJgB) - Deep, authoritative male voice
Bella (EXAVITQu4vr4xnSDxMaL) - Soft, friendly female voice
Antoni (ErXwobaYiN019PkySvjV) - Well-rounded male voice

You can also create custom voices or clone voices using the ElevenLabs platform. Visit the ElevenLabs Voice Library to explore more options.

Use Cases

The Cerebras + ElevenLabs integration is perfect for:

Voice Assistants - Build responsive AI assistants with natural conversation flow
Content Creation - Generate and narrate articles, stories, or educational content
Customer Service - Create automated voice support systems with human-like responses
Accessibility Tools - Convert text content to speech for visually impaired users
Interactive Experiences - Build voice-enabled games, tours, or educational apps
Podcast Generation - Automatically create podcast episodes from text content

FAQ

Audio playback not working

If you’re having trouble playing audio:

Ensure you have audio output devices properly configured
Try saving the audio to a file instead of playing directly:

# Assuming you have audio from elevenlabs_client.text_to_speech.convert()
# audio = elevenlabs_client.text_to_speech.convert(...)

# Save to file instead of playing
# with open("output.mp3", "wb") as f:
#     for chunk in audio:
#         f.write(chunk)

Install additional audio libraries if needed: pip install sounddevice soundfile

High latency in responses

To reduce latency:

Use streaming for both text generation and audio synthesis (see Step 6)
Keep responses concise by setting lower max_completion_tokens values
Use faster Cerebras models like gpt-oss-120b for simpler tasks
Consider caching common responses

Available Models

Cerebras offers several models optimized for voice AI applications:

Model	Parameters	Best For
gpt-oss-120b	120B	Largest model for the most demanding tasks
zai-glm-4.7	357B	Advanced 357B parameter model with strong reasoning capabilities

Simply change the model parameter in your Cerebras API calls to switch between models.

Next Steps

Explore the ElevenLabs API documentation for advanced features like voice cloning and dubbing
Try different Cerebras models like gpt-oss-120b for specialized tasks
Experiment with streaming responses for even lower latency
Learn about structured outputs to format responses for voice synthesis
Check out the ElevenLabs Voice Library for more voice options
Migrate to GLM4.7: Ready to upgrade? Follow our migration guide to start using our latest model

Integrations

Agentic Frameworks

AI Development Kits

Coding Tools

Containerization

Observability & Evaluation

LLM Integration Tools

LLM Application Frameworks

Document Processing

Real-Time Audio

Multi-LLM Management

No-Code/Low-Code Platforms

Prerequisites

Configure ElevenLabs Integration

Voice Selection

Use Cases

FAQ

Available Models

Next Steps

Additional Resources

​Prerequisites

​Configure ElevenLabs Integration

​Voice Selection

​Use Cases

​FAQ

​Available Models

​Next Steps

​Additional Resources

Prerequisites

Configure ElevenLabs Integration

Voice Selection

Use Cases

FAQ

Available Models

Next Steps

Additional Resources