Python SDK

pip install sixtydb

from sixtydb import SixtyDBClient

# Simple initialization
client = SixtyDBClient('your-api-key')

# With custom base URL
client = SixtyDBClient('your-api-key', base_url='https://api.60db.ai')

# Get all voices
voices = client.get_voices()

# Get all languages
languages = client.get_languages()

audio = client.text_to_speech(
    text='Hello, world!',
    voice_id='default-voice',
    enhance=True,
    speed=1.0,
    language='en-us'
)

# Save to file
with open('output.mp3', 'wb') as f:
    f.write(audio)

with open('audio.mp3', 'rb') as audio_file:
    result = client.speech_to_text(audio_file, language='en')
    print(result['text'])

with open('audio.mp3', 'rb') as audio_file:
    result = client.speech_to_text(
        audio_file,
        language='hi',
        diarize=True,
        context='Cricket coaching session. Players: Arjun Mehta, Ishaan Verma. Discussing batting technique.',
    )
    print(result['text'])

languages = client.get_languages()
for lang in languages:
    print(f"{lang['name']} ({lang['code']})")

voices = client.get_voices()
for voice in voices:
    print(f"{voice['name']} ({voice['id']})")

voice = client.get_voice('voice-id')
print(voice)

files = [
    open('sample1.mp3', 'rb'),
    open('sample2.mp3', 'rb'),
    open('sample3.mp3', 'rb')
]

new_voice = client.create_voice(
    name='My Custom Voice',
    files=files,
    description='A custom voice for my brand'
)

print(f"Created voice: {new_voice['id']}")

# Close files
for f in files:
    f.close()

client.update_voice(
    voice_id='voice-id',
    name='Updated Voice Name',
    description='Updated description'
)

client.delete_voice('voice-id')

response = client.chat.completion(
    model='60db-tiny',
    messages=[{'role': 'user', 'content': 'How can I improve my English?'}]
)
print(response['choices'][0]['message']['content'])

# Streaming
for chunk in client.chat.completion(
    messages=[{'role': 'user', 'content': 'Tell me a short story'}],
    stream=True
):
    print(chunk['choices'][0]['delta'].get('content') or '', end='')

# Text correction mode
fixed = client.chat.completion(
    text='hello how r u',
    dictionary=[{'term': 'u', 'replacement': 'you'}],
    app_context='email'
)

# OpenAI-style alias
response = client.chat.completions.create(model='60db-tiny', messages=[...])

client.memory.ingest(text='I prefer vegetarian food', type='user', infer=True)
client.memory.extract_document('handbook.pdf', collection='company_handbook', type='knowledge')

results = client.memory.search(query='What are my dietary preferences?', max_results=5)
ctx = client.memory.context(query='What do you know about me?', top_k=8)
print(ctx['data']['prompt_ready'])

usage = client.memory.usage()

tts_models = client.get_tts_models()['data']
stt_models = client.get_stt_models()['data']
tts_languages = client.get_tts_languages()['data']
my_voices = client.get_my_voices()['data']  # custom voices in your workspace

result = client.music.create(
    prompt='upbeat lo-fi hip hop',
    mode='simple'
)
song_id = result['data']['songs'][0]['id']

song = client.music.wait_for_completion(song_id, interval=4, timeout=600)

audio_bytes = client.music.download(song_id)
with open('my-song.mp3', 'wb') as f:
    f.write(audio_bytes)

run = client.judge.evaluate(
    state=call_transcript,
    questions={
        "tone": {
            "type": "choice",
            "instructions": "How did the agent come across?",
            "criteria": {
                "professional": "Calm, courteous, takes ownership",
                "dismissive": "Brushes the caller off",
                "unknown": "Not enough of the call to tell",   # always add an escape hatch
            },
        },
        "satisfaction": {"type": "score", "criteria": ["Angry", "Neutral", "Happy"]},
        "resolved": {"type": "noul", "instructions": "Was it solved?"},
    },
)

run["answers"]["tone"]["choice"]          # 'dismissive'
run["answers"]["tone"]["probabilities"]   # {'dismissive': 0.86, 'professional': 0.11, ...}
run["answers"]["satisfaction"]["score"]   # 1.87 — weighted, not an index
run["answers"]["resolved"]["noul"]        # 0.28 — probability of true, not a confidence
run["min_confidence"]                     # under 0.85 → send to a human
run["credits_charged"]

rubric = client.judge.rubrics.create(
    name="Call QA",
    description="Tone, satisfaction and outcome on inbound calls",
    questions=questions,
    shared=True,            # workspace-wide; owner/admin only
)

client.judge.evaluate(state=transcript, rubric_id=rubric["id"])

client.judge.rubrics.list()
client.judge.rubrics.get(rubric_id)
client.judge.rubrics.update(rubric_id, description="updated")
client.judge.rubrics.delete(rubric_id)

turn = client.judge.extract(
    text="move my 10am appointment to friday",
    schema={
        "intents": {"booking": "Wants to arrange or change a booking"},
        "operations": {"reschedule": "Move an existing booking"},
        "entities": {"date": "A calendar date", "time": "A clock time"},
        # "responsePaths": {"confirm": "Read the change back"}   ← selects the v2 model
    },
)

turn["intent"]["label"]      # 'booking'
turn["entities"]             # [{'label': 'date', 'text': 'friday', 'start': 28, 'end': 34, ...}]

page = client.judge.runs.list(needs_review=True, limit=20)
page["runs"]         # only runs the judge was under 85% sure about
page["pagination"]   # {'total': ..., 'limit': ..., 'has_more': ...}

client.judge.runs.get(run_id)      # one run, with what was sent and returned
client.judge.runs.delete(run_id)

client.judge.models()                 # authoritative list — don't hardcode
client.judge.usage("current_month")   # spend and run counts
client.judge.health()                 # upstream readiness (owner/admin)

status = client.dialer.status()
print('Provisioned:', status['data']['provisioned'])

bought = client.dialer.numbers.buy()
print('Bought:', bought['data']['number'])

calls = client.dialer.calls.list(limit=50)

url = client.dialer.recordings.playback_url('recording-id')
print('Listen at:', url['data']['playback_url'])

user = client.sign_up(
    email='[email protected]',
    password='secure-password',
    name='John Doe'
)

session = client.sign_in(
    email='[email protected]',
    password='secure-password'
)

print(f"Token: {session['token']}")

profile = client.get_profile()
print(profile)

client.update_profile(
    name='Jane Doe',
    company='Acme Inc'
)

workspaces = client.get_workspaces()

workspace = client.create_workspace(
    name='My Workspace',
    description='Team workspace'
)

plans = client.get_plans()
for plan in plans:
    print(f"{plan['name']}: ${plan['price']}/month")

usage = client.get_usage()
print(f"Characters used: {usage['characters']}")
print(f"API calls: {usage['api_calls']}")

api_keys = client.get_api_keys()

new_key = client.create_api_key('Production Key')
print(f"New API key: {new_key['key']}")

client.delete_api_key('key-id')

webhooks = client.get_webhooks()

webhook = client.create_webhook(
    url='https://example.com/webhook',
    events=['tts.completed', 'stt.completed']
)

client.delete_webhook('webhook-id')

from requests.exceptions import HTTPError

try:
    audio = client.text_to_speech(
        text='Hello, world!',
        voice_id='invalid-voice'
    )
except HTTPError as e:
    print(f"HTTP Error: {e.response.status_code}")
    print(f"Message: {e.response.json()['message']}")
except Exception as e:
    print(f"Error: {str(e)}")

from sixtydb import SixtyDBClient
from typing import Dict, List, Any

client: SixtyDBClient = SixtyDBClient('your-api-key')
voices: List[Dict[str, Any]] = client.get_voices()

import asyncio
from sixtydb import SixtyDBClient

async def main():
    client = SixtyDBClient('your-api-key')

    # Run in executor for async compatibility
    loop = asyncio.get_event_loop()
    audio = await loop.run_in_executor(
        None,
        client.text_to_speech,
        'Hello, world!',
        'default-voice'
    )

    with open('output.mp3', 'wb') as f:
        f.write(audio)

asyncio.run(main())