curl https://your-engine.com/api/laml/2010-04-01/Accounts/{ProjectID}/Calls.json \
  -u "{ProjectID}:{AuthToken}"

pip install wirexaapi

# Before (SignalWire official SDK or signalwire_replacement.py)
from signalwire.rest import Client as SignalWireClient

# After — rest of your code stays the same
from wirexaapi import Client as SignalWireClient

{
  "signalwire": {
    "project_id": "your_project_id",
    "api_token": "PTxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    "space_url": "wirexaapi.com"
  }
}

import json
from wirexaapi import Client as SignalWireClient

with open("settings.json") as f:
    jsonsettings = json.load(f)

sw = jsonsettings["signalwire"]

signalwire_client = SignalWireClient(
    sw["project_id"],
    sw["api_token"],
    signalwire_space_url=sw["space_url"],
)

call = signalwire_client.calls.create(
    to="+13125551234",
    from_="+18005550100",
    url="https://your-backend.com/xml",
    status_callback="https://your-backend.com/status",
    status_callback_event=["initiated", "ringing", "completed"],
    recording_status_callback="https://your-backend.com/recording-status",
    machine_detection="Enable",
    record=True,
)
print(call.sid, call.status)  # CAxxxxxxxx  queued

from flask import Flask, request, Response
app = Flask(__name__)

@app.route("/xml", methods=["POST"])
def xml_response():
    xml = """<?xml version="1.0" encoding="UTF-8"?>
<Response>
  <Say>Hello! This call is being recorded.</Say>
  <Gather numDigits="1" timeout="5" action="/gather">
    <Say>Press 1 for sales, 2 for support.</Say>
  </Gather>
  <Hangup/>
</Response>"""
    return Response(xml, mimetype="text/xml")

@app.route("/gather", methods=["POST"])
def gather():
    digit = request.form.get("Digits", "")
    xml = f"<Response><Say>You pressed {digit}.</Say><Hangup/></Response>"
    return Response(xml, mimetype="text/xml")

@app.route("/status", methods=["POST"])
def status():
    print(request.form)  # CallSid, CallStatus, AnsweredBy, etc.
    return "OK"

curl -X POST "http://wirexaapi.com/api/laml/2010-04-01/Accounts/{ProjectID}/Calls.json" \
  -u "{ProjectID}:{AuthToken}" \
  --data-urlencode "To=+13125551234" \
  --data-urlencode "From=+18005550100" \
  --data-urlencode "Url=https://your-backend.com/xml" \
  --data-urlencode "StatusCallback=https://your-backend.com/status" \
  --data-urlencode "MachineDetection=Enable" \
  --data-urlencode "Record=true" \
  --data-urlencode "RecordingStatusCallback=https://your-backend.com/recording-status"

{
  "sid": "CAxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
  "account_sid": "your_project_id",
  "to": "+13125551234",
  "from": "+18005550100",
  "status": "queued",
  "direction": "outbound-api",
  "url": "https://your-backend.com/xml"
}

# List all calls (most recent first)
curl "http://wirexaapi.com/api/laml/2010-04-01/Accounts/{ProjectID}/Calls.json" \
  -u "{ProjectID}:{AuthToken}"

# Filter by status
curl "http://wirexaapi.com/api/laml/2010-04-01/Accounts/{ProjectID}/Calls.json?Status=completed&PageSize=50" \
  -u "{ProjectID}:{AuthToken}"

# Get a specific call
curl "http://wirexaapi.com/api/laml/2010-04-01/Accounts/{ProjectID}/Calls/{CallSid}.json" \
  -u "{ProjectID}:{AuthToken}"

# Hang up a call
curl -X POST "http://wirexaapi.com/api/laml/2010-04-01/Accounts/{ProjectID}/Calls/{CallSid}.json" \
  -u "{ProjectID}:{AuthToken}" \
  --data-urlencode "Status=completed"

<Response>
  <Say language="en-US" voice="polly.Joanna" loop="1">
    Hello! Thank you for calling.
  </Say>
</Response>

<Response>
  <Play loop="1">https://example.com/greeting.wav</Play>
</Response>

<Response>
  <Gather numDigits="1" timeout="7"
          action="https://your-backend.com/gather" method="POST">
    <Say>Press 1 for sales, 2 for support, or 3 to repeat.</Say>
  </Gather>
  <!-- Fallback if no digits collected: -->
  <Say>We did not receive your input. Goodbye.</Say>
  <Hangup/>
</Response>

<Response>
  <Say>Please leave your message after the tone.</Say>
  <Record maxLength="60" silence="5"
          action="https://your-backend.com/after-record"
          method="POST"/>
</Response>

<Response>
  <Dial timeout="30" callerId="+18005550100">
    +13125551234
  </Dial>
</Response>

<Response>
  <!-- Pause for 2 seconds -->
  <Pause length="2"/>

  <!-- Redirect to a new URL (replaces remaining verbs) -->
  <Redirect method="GET">https://your-backend.com/next-step</Redirect>

  <!-- Hang up the call -->
  <Hangup/>
</Response>

# By recording SID
curl "http://wirexaapi.com/recordings/{RecordingSid}.mp3" -o call.mp3
curl "http://wirexaapi.com/recordings/{RecordingSid}.wav" -o call.wav

# By call SID (first completed recording)
curl "http://wirexaapi.com/recordings/call/{CallSid}.mp3" -o call.mp3

# Recording metadata (JSON)
curl "http://wirexaapi.com/2010-04-01/Accounts/{ProjectID}/Recordings/{RecordingSid}.json"

{
  "detail": "No credits remaining for this project"
}

pip install fastapi uvicorn httpx python-multipart

# The Voice Engine base URL
ENGINE_URL=https://wirexaapi.com

# Your credentials — copy from the Dashboard
ACCOUNT_SID=your_project_id
AUTH_TOKEN=your_api_token

# Public URL of YOUR backend (Engine needs this to reach your webhooks)
# Use ngrok during local development: ngrok http 9000
MY_PUBLIC_URL=https://your-backend.example.com

uvicorn app:app --port 9000 --reload

import os, httpx
from fastapi import FastAPI

app = FastAPI()

ENGINE_URL    = os.getenv("ENGINE_URL",   "https://wirexaapi.com")
ACCOUNT_SID   = os.getenv("ACCOUNT_SID", "your_project_id")
AUTH_TOKEN    = os.getenv("AUTH_TOKEN",  "your_api_token")
MY_PUBLIC_URL = os.getenv("MY_PUBLIC_URL","https://your-backend.example.com")


@app.post("/call")
async def create_call(to: str, from_number: str = "+10000000000"):
    async with httpx.AsyncClient(timeout=15) as client:
        r = await client.post(
            f"{ENGINE_URL}/api/laml/2010-04-01/Accounts/{ACCOUNT_SID}/Calls.json",
            auth=(ACCOUNT_SID, AUTH_TOKEN),
            data={
                "To":                     to,
                "From":                   from_number,
                "Url":                    f"{MY_PUBLIC_URL}/xml",          # (2)
                "Method":                 "POST",
                "StatusCallback":         f"{MY_PUBLIC_URL}/status",       # (6)
                "StatusCallbackMethod":   "POST",
                # Optional: answering machine detection
                "MachineDetection":       "Enable",
                "AsyncAmd":               "true",
                "AsyncAmdStatusCallback": f"{MY_PUBLIC_URL}/amd",          # (5)
            },
        )
    data = r.json()
    return {"call_sid": data.get("sid"), "status": data.get("status")}

from fastapi import Request
from fastapi.responses import PlainTextResponse

@app.post("/xml", response_class=PlainTextResponse)
async def xml_instructions(request: Request) -> str:
    form = dict(await request.form())
    call_sid    = form.get("CallSid", "")
    answered_by = form.get("AnsweredBy", "")

    # Route differently if a machine answered
    if answered_by == "machine_start":
        return """<?xml version="1.0" encoding="UTF-8"?>
<Response>
  <Say>Please call us back at our office. Thank you.</Say>
  <Hangup/>
</Response>"""

    # Human answered — play IVR menu
    return f"""<?xml version="1.0" encoding="UTF-8"?>
<Response>
  <Say>Hello, thank you for answering.</Say>
  <Gather numDigits="1" timeout="7"
          action="{MY_PUBLIC_URL}/gather" method="POST">
    <Say>
      Press 1 for sales.
      Press 2 for support.
      Press 9 to be removed from our list.
    </Say>
  </Gather>
  <Say>We did not receive your selection. Goodbye.</Say>
  <Hangup/>
</Response>"""

@app.post("/gather", response_class=PlainTextResponse)
async def gather(request: Request) -> str:
    form   = dict(await request.form())
    digits = form.get("Digits", "")

    if digits == "1":
        return """<Response>
  <Say>Connecting you to sales. Please hold.</Say>
  <Transfer timeout="30">+13125550100</Transfer>
</Response>"""

    elif digits == "2":
        return """<Response>
  <Say>Our support team will email you shortly. Goodbye.</Say>
  <Hangup/>
</Response>"""

    elif digits == "9":
        # TODO: mark number as do-not-call in your database
        return """<Response>
  <Say>You have been removed from our list. Goodbye.</Say>
  <Hangup/>
</Response>"""

    else:
        # Unrecognised digit — repeat menu
        return f"""<Response>
  <Gather numDigits="1" timeout="7"
          action="{MY_PUBLIC_URL}/gather" method="POST">
    <Say>Invalid option. Press 1 for sales, 2 for support.</Say>
  </Gather>
  <Hangup/>
</Response>"""

@app.post("/amd")
async def amd_result(request: Request) -> dict:
    form        = dict(await request.form())
    call_sid    = form.get("CallSid", "")
    answered_by = form.get("AnsweredBy", "")  # human | machine_start | unknown
    confidence  = form.get("AmdConfidence", "")
    time_ms     = form.get("AmdDetectionTimeMs", "")

    print(f"[{call_sid}] AMD: {answered_by} (confidence={confidence}, {time_ms}ms)")

    if answered_by == "machine_start":
        # Optionally redirect the call to leave a voicemail
        async with httpx.AsyncClient(timeout=10) as client:
            await client.post(
                f"{ENGINE_URL}/api/laml/2010-04-01/Accounts/{ACCOUNT_SID}/Calls/{call_sid}.json",
                auth=(ACCOUNT_SID, AUTH_TOKEN),
                data={"Url": f"{MY_PUBLIC_URL}/xml/voicemail", "Method": "POST"},
            )

    return {"received": True}

@app.post("/status")
async def status_callback(request: Request) -> dict:
    form     = dict(await request.form())
    sid      = form.get("CallSid", "")
    status   = form.get("CallStatus", "")
    duration = form.get("CallDuration", "0")

    print(f"[{sid}] status={status} duration={duration}s")

    if status == "completed":
        pass  # update DB, send report, etc.
    elif status == "failed":
        pass  # retry logic, alert, etc.
    elif status == "no-answer":
        pass  # reschedule, etc.

    return {"received": True}

"""
IVR backend example — connects to the Wirexa Voice Engine.

Install:  pip install fastapi uvicorn httpx python-multipart
Run:      uvicorn app:app --port 9000 --reload
"""
from __future__ import annotations
import logging, os
import httpx
from fastapi import FastAPI, Request
from fastapi.responses import PlainTextResponse

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
log = logging.getLogger(__name__)

app = FastAPI()

ENGINE_URL    = os.getenv("ENGINE_URL",    "https://wirexaapi.com")
ACCOUNT_SID   = os.getenv("ACCOUNT_SID",  "your_project_id")
AUTH_TOKEN    = os.getenv("AUTH_TOKEN",    "your_api_token")
MY_PUBLIC_URL = os.getenv("MY_PUBLIC_URL", "https://your-backend.example.com")

AUTH = (ACCOUNT_SID, AUTH_TOKEN)
CALLS_URL = f"{ENGINE_URL}/api/laml/2010-04-01/Accounts/{ACCOUNT_SID}/Calls.json"


# ── 1. CREATE A CALL ──────────────────────────────────────────────────────────

@app.post("/call")
async def create_call(to: str, from_number: str = "+10000000000") -> dict:
    async with httpx.AsyncClient(timeout=15) as client:
        r = await client.post(CALLS_URL, auth=AUTH, data={
            "To":                     to,
            "From":                   from_number,
            "Url":                    f"{MY_PUBLIC_URL}/xml",
            "Method":                 "POST",
            "StatusCallback":         f"{MY_PUBLIC_URL}/status",
            "StatusCallbackMethod":   "POST",
            "MachineDetection":       "Enable",
            "AsyncAmd":               "true",
            "AsyncAmdStatusCallback": f"{MY_PUBLIC_URL}/amd",
        })
    data = r.json()
    log.info("Call created: %s → %s", data.get("sid"), to)
    return {"call_sid": data.get("sid"), "status": data.get("status")}


# ── 2. SERVE XML ──────────────────────────────────────────────────────────────

@app.post("/xml", response_class=PlainTextResponse)
async def xml_instructions(request: Request) -> str:
    form = dict(await request.form())
    log.info("[%s] XML requested — answered_by=%s", form.get("CallSid"), form.get("AnsweredBy"))

    return f"""<?xml version="1.0" encoding="UTF-8"?>
<Response>
  <Say>Hello, thank you for answering.</Say>
  <Gather numDigits="1" timeout="7"
          action="{MY_PUBLIC_URL}/gather" method="POST">
    <Say>
      Press 1 for sales.
      Press 2 for support.
      Press 9 to be removed from our list.
    </Say>
  </Gather>
  <Say>We did not receive your selection. Goodbye.</Say>
  <Hangup/>
</Response>"""


# ── 3. HANDLE GATHER ─────────────────────────────────────────────────────────

@app.post("/gather", response_class=PlainTextResponse)
async def gather(request: Request) -> str:
    form   = dict(await request.form())
    digits = form.get("Digits", "")
    log.info("[%s] Gather: digits=%r", form.get("CallSid"), digits)

    if digits == "1":
        return """<Response>
  <Say>Connecting you to sales.</Say>
  <Transfer timeout="30">+13125550100</Transfer>
</Response>"""
    elif digits == "2":
        return """<Response>
  <Say>Our team will contact you. Goodbye.</Say>
  <Hangup/>
</Response>"""
    elif digits == "9":
        return """<Response>
  <Say>You have been removed from our list. Goodbye.</Say>
  <Hangup/>
</Response>"""
    else:
        return f"""<Response>
  <Gather numDigits="1" timeout="7"
          action="{MY_PUBLIC_URL}/gather" method="POST">
    <Say>Invalid option. Press 1 for sales, 2 for support.</Say>
  </Gather>
  <Hangup/>
</Response>"""


# ── 4. AMD RESULT ─────────────────────────────────────────────────────────────

@app.post("/amd")
async def amd_result(request: Request) -> dict:
    form        = dict(await request.form())
    call_sid    = form.get("CallSid", "")
    answered_by = form.get("AnsweredBy", "")
    log.info("[%s] AMD: %s (%sms)", call_sid, answered_by, form.get("AmdDetectionTimeMs"))
    # Redirect to voicemail XML if machine answered
    if answered_by == "machine_start":
        async with httpx.AsyncClient(timeout=10) as client:
            await client.post(
                f"{ENGINE_URL}/api/laml/2010-04-01/Accounts/{ACCOUNT_SID}/Calls/{call_sid}.json",
                auth=AUTH,
                data={"Url": f"{MY_PUBLIC_URL}/xml/voicemail", "Method": "POST"},
            )
    return {"received": True}


# ── 5. STATUS CALLBACK ────────────────────────────────────────────────────────

@app.post("/status")
async def status_callback(request: Request) -> dict:
    form   = dict(await request.form())
    sid    = form.get("CallSid", "")
    status = form.get("CallStatus", "")
    log.info("[%s] status=%s duration=%ss", sid, status, form.get("CallDuration", "0"))
    # TODO: update your database here
    return {"received": True}


# ── HEALTH ────────────────────────────────────────────────────────────────────

@app.get("/health")
async def health() -> dict:
    try:
        async with httpx.AsyncClient(timeout=5) as c:
            r = await c.get(f"{ENGINE_URL}/health")
            engine_ok = r.status_code == 200
    except Exception:
        engine_ok = False
    return {"backend": "ok", "engine_connected": engine_ok}