Deepgram Aura TTS - Burki Voice AI Docs

⚡ Deepgram Aura: Low-Latency TTS

Deepgram Aura is optimized for realtime phone calls, live chat, and interactive applications. Measure latency in your own call path because timings vary by network, model, and deployment.

Quick Setup

Get API Key

Visit Deepgram Console and create an account
Navigate to API Keys in the dashboard
Create a new API key with TTS permissions
Copy your API key

Configure in Burki

Go to AI Configuration → TTS tab
Select Deepgram as provider
Paste your API key in the TTS API Key field

Select Aura Model

Choose Aura-2 for best quality or Aura for proven stability

Free Credits: Deepgram provides $200 in free credits to get started. Perfect for testing and small-scale deployments.

Available Models

🚀 Aura-2

Vendor-reported very low latencyNext-generation model with improved qualityBest for: Production phone calls, live applications Status: Latest and recommended

⚖️ Aura

~85ms latencyProven stable model with consistent qualityBest for: Stable production environments Status: Battle-tested, reliable

Recommendation: Use Aura-2 for the latest quality improvements and fastest response times.

Available Voices

Deepgram Aura Voices

Female Voices

Asteria

Warm and expressivePerfect for customer service and supportVoice ID: aura-asteria-en

Luna

Soft and melodicGreat for gentle, calming interactionsVoice ID: aura-luna-en

Stella

Bright and clearExcellent for announcements and alertsVoice ID: aura-stella-en

Athena

Intelligent and clearProfessional and articulateVoice ID: aura-athena-en

Male Voices

Orion

Deep and authoritativePerfect for business and professional useVoice ID: aura-orion-en

Helios

Bright and energeticGreat for upbeat, engaging contentVoice ID: aura-helios-en

Perseus

Strong and heroic (Aura-2 only)Commanding presence for leadership contentVoice ID: aura-2-perseus-en

Apollo

Musical and expressive (Aura-2 only)Rich, versatile voice for varied contentVoice ID: aura-2-apollo-en

Complete Voice List

Voice	Gender	Model	Voice ID	Best For
Asteria	Female	Aura/Aura-2	`aura-asteria-en`	Customer service
Thalia	Female	Aura-2	`aura-2-thalia-en`	Professional calls
Luna	Female	Aura/Aura-2	`aura-luna-en`	Gentle interactions
Stella	Female	Aura/Aura-2	`aura-stella-en`	Clear announcements
Athena	Female	Aura/Aura-2	`aura-athena-en`	Business calls
Hera	Female	Aura/Aura-2	`aura-hera-en`	Authoritative voice
Orion	Male	Aura/Aura-2	`aura-orion-en`	Professional use
Helios	Male	Aura/Aura-2	`aura-helios-en`	Energetic content
Perseus	Male	Aura-2	`aura-2-perseus-en`	Leadership content
Apollo	Male	Aura-2	`aura-2-apollo-en`	Versatile applications

Phone Call Optimization

📞 Twilio Integration

Deepgram Aura is specifically optimized for phone systems with built-in Twilio compatibility.

Audio Format Settings

µ-law Encoding
Linear PCM

Recommended for Twilio

{
  "encoding": "mulaw",
  "sample_rate": 8000
}

Format: G.711 µ-law
Sample Rate: 8kHz
Best for: Phone calls, VoIP systems
Quality: Optimized for voice clarity over networks

High Quality Option

{
  "encoding": "linear16",
  "sample_rate": 24000
}

Format: Linear PCM
Sample Rate: 24kHz
Best for: High-quality applications
Quality: Maximum audio fidelity

For Phone Calls: Always use µ-law encoding at 8kHz sample rate for optimal compatibility with Twilio and other phone systems.

Performance Metrics

⚡ Latency

Low-latency streamingFrom text input to first audio chunk3x faster than most competitors

🎯 Reliability

Provider-backed uptimeProduction reliability depends on your Deepgram plan and configured fallbacksUse fallback providers for critical paths

📊 Throughput

High concurrencyScales automatically with demandNo rate limit bottlenecks

API Integration

import asyncio
import websockets
import json
import base64

async def stream_tts():
    uri = "wss://api.deepgram.com/v1/speak?model=aura-asteria-en&encoding=mulaw&sample_rate=8000"
    
    headers = {
        "Authorization": "Token YOUR_DEEPGRAM_API_KEY"
    }
    
    async with websockets.connect(uri, extra_headers=headers) as websocket:
        # Send text
        await websocket.send(json.dumps({
            "type": "speak",
            "text": "Hello from Deepgram Aura!"
        }))
        
        # Receive audio chunks
        async for message in websocket:
            data = json.loads(message)
            if data.get("type") == "audio":
                audio_data = base64.b64decode(data["data"])
                # Process audio data
                yield audio_data

Configuration Examples

Phone Calls
Live Chat
Announcements

Optimal Settings for Phone Systems

{
  "model": "aura-2-asteria-en",
  "encoding": "mulaw",
  "sample_rate": 8000,
  "text": "Thank you for calling. How can I help you today?"
}

Ultra-low latency for real-time conversation
Phone-compatible audio format
Clear, professional voice

Real-time Web Applications

{
  "model": "aura-2-luna-en",
  "encoding": "linear16",
  "sample_rate": 24000,
  "text": "I'm here to help! What can I assist you with?"
}

High-quality audio for web playback
Friendly, approachable voice
Fast response times

System Alerts & Notifications

{
  "model": "aura-stella-en",
  "encoding": "linear16",
  "sample_rate": 16000,
  "text": "Attention: Your appointment reminder is ready."
}

Clear, attention-getting voice
Balanced quality and file size
Professional tone

Best Practices

🚀 Optimization Tips

Maximize Deepgram’s Speed Advantage

Text Chunking

Send text in optimal chunks for best latency

Ideal chunk size: 20-50 words
Avoid: Sending entire paragraphs at once
Benefit: Faster time to first audio

def chunk_text(text, max_words=30):
    words = text.split()
    chunks = []
    current_chunk = []
    
    for word in words:
        current_chunk.append(word)
        if len(current_chunk) >= max_words:
            chunks.append(' '.join(current_chunk))
            current_chunk = []
    
    if current_chunk:
        chunks.append(' '.join(current_chunk))
    
    return chunks

Connection Reuse

Keep WebSocket connections alive for multiple requests

Pattern: One connection per conversation
Benefit: Eliminates connection overhead
Implementation: Reuse WebSocket for entire call session

Error Handling

Implement robust error handling for production

async def robust_tts_stream():
    max_retries = 3
    retry_count = 0
    
    while retry_count < max_retries:
        try:
            # Your TTS streaming code here
            break
        except websockets.exceptions.ConnectionClosed:
            retry_count += 1
            await asyncio.sleep(1)  # Brief pause before retry
        except Exception as e:
            logger.error(f"TTS error: {e}")
            break

Pricing

💰 Simple, Predictable Pricing

Pay-per-character with volume discounts. No hidden fees or subscription tiers.

Usage Tier	Price per Character	Best For
First 10M chars/month	$0.0135	Small to medium businesses
Next 90M chars/month	$0.0108	Growing applications
Next 400M chars/month	$0.0081	Enterprise usage
500M+ chars/month	Custom pricing	Large-scale deployments

Free Credits: New accounts receive

200 in credits. Average phone call costs ~

0.03 in TTS usage.

Language Support

Current Limitation: Deepgram Aura currently supports English only. Multi-language support is planned for future releases.

🇺🇸 English Optimizations

Specialized for English-language applications

Native English training data
Optimized for American English pronunciation
Best-in-class quality for English content
Perfect for US-based business applications

Troubleshooting

High Latency Issues

Problem: Response time slower than expectedSolutions:

Verify you’re using Aura-2 model
Check network connection quality
Ensure µ-law encoding for phone calls
Monitor concurrent connection limits

Audio Quality Problems

Problem: Distorted or unclear audioSolutions:

Use correct encoding (µ-law for phones, linear16 for high quality)
Verify sample rate matches your playback system
Check API key permissions include TTS
Test with shorter text chunks

Connection Drops

Problem: WebSocket connection terminates unexpectedlySolutions:

Implement connection keepalive pings
Add automatic reconnection logic
Monitor connection health
Use exponential backoff for retries

Migration from Other Providers

From ElevenLabs
From Google/AWS

Key Differences:

3x faster latency (75ms vs 250ms)
English-only vs multilingual
WebSocket-only vs REST+WebSocket
Different voice ID format

Migration Tips:

Map ElevenLabs voices to Deepgram equivalents
Update API calls to WebSocket format
Adjust audio encoding for your use case

⚡ Ready for Ultra-Fast TTS?

Configure Deepgram Aura in your assistant settings and experience the speed difference in your phone calls!

Documentation Index

⚡ Deepgram Aura: Low-Latency TTS

​Quick Setup

​Available Models

🚀 Aura-2

⚖️ Aura

​Available Voices

​Deepgram Aura Voices

Asteria

Luna

Stella

Athena

Orion

Helios

Perseus

Apollo

​Phone Call Optimization

📞 Twilio Integration

​Audio Format Settings

​Performance Metrics

⚡ Latency

🎯 Reliability

📊 Throughput

​API Integration

​Configuration Examples

​Best Practices

🚀 Optimization Tips

​Pricing

💰 Simple, Predictable Pricing

​Language Support

🇺🇸 English Optimizations

​Troubleshooting

​Migration from Other Providers

⚡ Ready for Ultra-Fast TTS?

Quick Setup

Available Models

Available Voices

Deepgram Aura Voices

Phone Call Optimization

Audio Format Settings

Performance Metrics

API Integration

Configuration Examples

Best Practices

Pricing

Language Support

Troubleshooting

Migration from Other Providers