Python SDK

import os
from outcallerai import OutCallerAI

with OutCallerAI(os.environ["OUTCALLERAI_API_KEY"]) as client:
    workspace = client.workspace.get_workspace()
    print(workspace.name)

from outcallerai import OutCallerAI

client = OutCallerAI(
    api_key=os.environ["OUTCALLERAI_API_KEY"],
    base_url="https://api.outcallerai.com",
    timeout=60.0,
    max_retries=3,
    response_hook=lambda meta: print(
        f"{meta.method} {meta.path} -> {meta.status} ({meta.duration:.0f}s)"
    ),
)

# Get workspace
workspace = client.workspace.get_workspace()
print(workspace.id, workspace.name)

# Update workspace name
updated = client.workspace.update_workspace(
    workspace_update_request={"name": "Acme Corp"}
)

# List usecases
usecases = client.usecases.list_usecases()

# Get usecase by ID
usecase = client.usecases.get_usecase(use_case_id="uc_abc123")

# Create usecase
created = client.usecases.create_usecase(
    use_case_write_request={"name": "Q4 Outreach", "description": "Quarterly sales push"}
)

# Update usecase
updated = client.usecases.update_usecase(
    use_case_id="uc_abc123",
    use_case_write_request={"name": "Updated Usecase"}
)

# Delete usecase
client.usecases.delete_usecase(use_case_id="uc_abc123")

# List agents
agents = client.agents.list_agents()

# Get agent by ID
agent = client.agents.get_agent(agent_id="ag_abc123")

# Create agent
created = client.agents.create_agent(
    agent_create_request={"name": "Sales Agent", "gender": "female"}
)

# Update agent
updated = client.agents.update_agent(
    agent_id="ag_abc123",
    agent_update_request={"name": "Updated Name", "gender": "male"}
)

# Delete agent
client.agents.delete_agent(agent_id="ag_abc123")

# List leads for an agent
leads = client.leads.list_leads(agent_id="ag_abc123", limit=50)

# Get lead by ID
lead = client.leads.get_lead(agent_id="ag_abc123", lead_id="ld_xyz789")

# Create lead (single or bulk)
from outcallerai.generated.models.lead_create_request import LeadCreateRequest
from outcallerai.generated.models.body import Body
new_leads = client.leads.create_lead(
    agent_id="ag_abc123",
    body=Body(actual_instance=[
        LeadCreateRequest(
            name="Jane Doe",
            email="jane@example.com",
            phone="+911234567890",
            description="Interested in pricing",
        )
    ])
)

# Update lead
updated_lead = client.leads.update_lead(
    agent_id="ag_abc123",
    lead_id="ld_xyz789",
    lead_update_request={"name": "Jane Smith"}
)

# Delete lead
client.leads.delete_lead(agent_id="ag_abc123", lead_id="ld_xyz789")

# List calls for an agent
calls = client.calls.list_calls(agent_id="ag_abc123", limit=50)

# Get call by ID
call = client.calls.get_call(agent_id="ag_abc123", call_id="cl_xyz789")

# Create call (initiate outbound call to a lead)
from outcallerai.generated.models.call_create_request import CallCreateRequest
new_calls = client.calls.create_call(
    agent_id="ag_abc123",
    call_create_request=CallCreateRequest(lead_id="ld_xyz789")
)
print(new_calls[0].id, new_calls[0].status)

# Bulk call creation (initiate calls to multiple leads at once)
bulk_calls = client.calls.create_call(
    agent_id="ag_abc123",
    call_create_request=CallCreateRequest(lead_ids=["ld_xyz789", "ld_abc456", "ld_def012"])
)
print(f"Created {len(bulk_calls)} calls")
for call in bulk_calls:
    print(call.id, call.status)

import uuid

# Create call export job
job = client.jobs.create_call_export_job(
    call_export_job_request={"agent_id": "ag_abc123", "limit": 100},
    idempotency_key=str(uuid.uuid4()),
)

# Get job status
job_status = client.jobs.get_job(job_handle=job.handle)

# Cancel job
client.jobs.cancel_job(job_handle=job.handle)

from outcallerai import Page, paginate


def fetch_page(cursor=None):
    response = client.leads.list_leads(
        agent_id="ag_abc123",
        cursor=cursor,
        limit=50,
    )
    return Page(
        items=response.items,
        next_cursor=response.next_cursor,
    )


for lead in paginate(fetch_page, max_pages=1_000):
    print(lead.id, lead.name)

import uuid

from outcallerai.generated.models.lead_create_request import LeadCreateRequest
from outcallerai.generated.models.body import Body

lead = client.leads.create_lead(
    agent_id="ag_abc123",
    body=Body(actual_instance=[
        LeadCreateRequest(
            name="Jane",
            email="jane@example.com",
            phone="+911234567890",
            description="Interested in pricing",
        )
    ]),
    idempotency_key=str(uuid.uuid4()),
)

from outcallerai import AuthenticationError, OutCallerAIError, RateLimitError

try:
    client.agents.create_agent(...)
except AuthenticationError:
    # The API key is invalid or has been revoked
    raise
except RateLimitError:
    # Back off - the SDK already retried when safe
    raise
except OutCallerAIError as error:
    print(error.category, error.code, error.request_id)
    raise

from outcallerai import ResponseMetadata


def observe(meta: ResponseMetadata):
    print(
        meta.method,
        meta.path,
        meta.status,
        meta.request_id,
        meta.rate_limit_remaining,
    )


client = OutCallerAI(
    os.environ["OUTCALLERAI_API_KEY"],
    response_hook=observe,
)