Python SDK

pip install murmr

from murmr import MurmrClient

client = MurmrClient(api_key="murmr_sk_live_...")

# Or as a context manager
with MurmrClient(api_key="murmr_sk_live_...") as client:
    wav = client.voices.design(
        input="Hello!",
        voice_description="A warm, friendly voice",
    )

job = client.speech.create(
    input="Hello, world!",
    voice="voice_abc123",
    language="English",
)

# job.id = "job_xyz", job.status = "queued"

# Poll for completion
result = client.jobs.wait_for_completion(job.id)
with open("output.wav", "wb") as f:
    f.write(result.audio_bytes)

result = client.speech.create_and_wait(
    input="Hello, world!",
    voice="voice_abc123",
    language="English",
    response_format="wav",
)

with open("output.wav", "wb") as f:
    f.write(result.audio_bytes)

with client.speech.stream(
    input="Real-time audio streaming.",
    voice="voice_abc123",
) as stream:
    for chunk in stream:
        pcm = chunk.audio_bytes  # 24kHz mono 16-bit PCM
        # Process: pipe to speaker, save, etc.
        if chunk.done:
            break

result = client.speech.create_long_form(
    input=long_article_text,
    voice="voice_abc123",
    language="English",
    chunk_size=3500,
    silence_between_chunks_ms=400,
    max_retries=3,
    on_progress=lambda current, total, pct: print(f"{pct}%"),
)

with open("article.wav", "wb") as f:
    f.write(result.audio)
print(f"{result.total_chunks} chunks, {result.duration_ms}ms total")

@dataclass(frozen=True)
class LongFormResult:
    audio: bytes          # WAV audio with silence gaps
    total_chunks: int     # Number of chunks processed
    duration_ms: float    # Total audio duration
    character_count: int  # Total characters processed

from murmr import MurmrChunkError

try:
    result = client.speech.create_long_form(input=text, voice=voice)
except MurmrChunkError as err:
    print(f"Failed at chunk {err.chunk_index}/{err.total_chunks}")

    # Retry from the failed chunk
    result = client.speech.create_long_form(
        input=text,
        voice=voice,
        start_from_chunk=err.chunk_index,
    )

wav = client.voices.design(
    input="Welcome to the show.",
    voice_description="A deep, gravelly male voice, slow and deliberate",
    language="English",
)

with open("output.wav", "wb") as f:
    f.write(wav)

with client.voices.design_stream(
    input="Streaming with a designed voice.",
    voice_description="A deep, authoritative male news anchor",
) as stream:
    for chunk in stream:
        pcm = chunk.audio_bytes
        if chunk.done:
            break

result = client.voices.extract_embeddings(
    audio=open("reference.wav", "rb").read(),
    ref_text="Transcript of the reference audio.",
)

# Use the embedding in a TTS request
with client.speech.stream(
    input="Hello from a portable voice!",
    voice="inline",
    voice_clone_prompt=result.prompt_data,
) as stream:
    for chunk in stream:
        pcm = chunk.audio_bytes

status = client.jobs.get("job_xyz")
# status.id, status.status ("queued"|"processing"|"completed"|"failed")

result = client.jobs.wait_for_completion(
    "job_xyz",
    poll_interval=3.0,     # default: 3s
    timeout=900.0,         # default: 15 min
)

from murmr import MurmrError, MurmrChunkError

try:
    audio = client.speech.create(input=text, voice=voice)
except MurmrError as err:
    print(err.message)    # "Usage limit exceeded..."
    print(err.status)     # 429
    print(err.code)       # "JOB_FAILED", "TIMEOUT", etc.

from murmr import (
    MurmrClient,
    AsyncMurmrClient,
    MurmrError,
    MurmrChunkError,
)

# Response models (Pydantic v2, frozen)
from murmr._types import (
    AsyncJobResponse,     # id, status, created_at
    JobStatus,            # id, status, audio_base64, audio_bytes
    AudioStreamChunk,     # audio_bytes, done
    LongFormResult,       # audio, total_chunks, duration_ms, character_count
)