Python SDK

pip install audixa

pip install aiofiles

import audixa

# Set your API key
audixa.set_api_key("your-api-key")
# Or use environment variable: AUDIXA_API_KEY

# Generate TTS and get audio URL
url = audixa.tts_and_wait(
    "Hello, world! Welcome to Audixa AI text-to-speech.",
    voice="am_ethan",
)
print(f"Audio URL: {url}")

# Or save directly to file
audixa.tts_to_file(
    "Hello, world! Welcome to Audixa.",
    "output.wav",
    voice="am_ethan",
)

import asyncio
import audixa

audixa.set_api_key("your-api-key")

async def main():
    # Generate TTS asynchronously
    url = await audixa.atts_and_wait(
        "Hello, world! This is async generation.",
        voice="am_ethan",
    )
    print(f"Audio URL: {url}")
    
    # Save to file
    await audixa.atts_to_file(
        "Hello from async world!",
        "output.wav",
        voice="am_ethan",
    )

asyncio.run(main())

import audixa

audixa.set_api_key("your-api-key")

# Base model with speed adjustment
audio_url = audixa.tts_and_wait(
    "Welcome to Audixa AI, your text-to-speech solution.",
    voice="am_ethan",
    model="base",
    speed=1.1,  # Slightly faster (0.5 to 2.0)
)

# Advance model with emotion
audio_url = audixa.tts_and_wait(
    "This is exciting news! We have launched.",
    voice="am_ethan",
    model="advance",
    emotion="happy",
    temperature=0.8,
    top_p=0.9,
    do_sample=True,
)

from audixa import AudixaClient

# Create client with custom settings
client = AudixaClient(
    api_key="your-api-key",
    timeout=60.0,
    max_retries=5,
)

# Use as context manager
with client:
    # Start generation (non-blocking)
    gen_id = client.tts(
        "Hello, world! Welcome to Audixa.",
        voice="am_ethan",
    )
    
    # Check status manually
    status = client.status(gen_id)
    print(f"Status: {status['status']}")
    
    # List available voices
    voices = client.list_voices()
    for voice in voices:
        print(f"{voice['id']}: {voice['name']}")

from audixa import AsyncAudixaClient
import asyncio

async def main():
    async with AsyncAudixaClient(
        api_key="your-api-key",
        max_concurrency=10,  # Rate limit protection
    ) as client:
        # Concurrent generation
        texts = [
            "First sentence to generate.",
            "Second sentence to generate.",
            "Third sentence to generate.",
        ]
        tasks = [
            client.tts_and_wait(text, voice="am_ethan")
            for text in texts
        ]
        urls = await asyncio.gather(*tasks)
        print(urls)

asyncio.run(main())

import audixa

try:
    audio_url = audixa.tts_and_wait(
        "Hello, this is a test message.",
        voice="am_ethan",
    )
except audixa.AuthenticationError:
    print("Invalid API key")
except audixa.RateLimitError as e:
    print(f"Rate limited. Retry after: {e.retry_after}s")
except audixa.TimeoutError:
    print("Generation timed out")
except audixa.GenerationError as e:
    print(f"Generation failed: {e.message}")
except audixa.NetworkError:
    print("Network error occurred")
except audixa.AudixaError as e:
    print(f"General error: {e}")

# Correct - WAV format
audixa.tts_to_file("Hello", "output.wav", voice="am_ethan")

# Error - MP3 not yet supported  
audixa.tts_to_file("Hello", "output.mp3", voice="am_ethan")  # Raises UnsupportedFormatError

import logging

# Enable debug logging
logging.basicConfig(level=logging.DEBUG)

# Or configure the audixa logger specifically
logging.getLogger("audixa").setLevel(logging.DEBUG)

export AUDIXA_API_KEY="your-api-key"

import audixa
# API key is automatically loaded from environment
audio_url = audixa.tts_and_wait("Hello!", voice="am_ethan")

import audixa
import time
import logging

def generate_audio(text: str, voice: str) -> str | None:
    try:
        return audixa.tts_and_wait(text, voice=voice, timeout=120)
    except audixa.RateLimitError:
        time.sleep(60)
        return generate_audio(text, voice)  # Retry
    except audixa.AudixaError as e:
        logging.error(f"TTS failed: {e}")
        return None

async def batch_generate(texts: list[str], voice: str) -> list[str]:
    async with AsyncAudixaClient(max_concurrency=5) as client:
        tasks = [client.tts_and_wait(text, voice=voice) for text in texts]
        return await asyncio.gather(*tasks, return_exceptions=True)

client = AudixaClient(
    api_key="your-key",
    timeout=60.0,      # HTTP request timeout
    max_retries=5,     # Retry attempts
)

audio_url = client.tts_and_wait(
    "Long text...",
    voice="am_ethan",
    timeout=300.0,     # Wait timeout for generation
)