Python Code to Turn Text Into Natural Speech During a Live Call

Use Telnyx Call Control to answer the call, then send a speak action containing your text after the call.answered webhook arrives. The Python/Flask example below keeps telephony and text-to-speech in one call-control flow, so your application can deliver a clear, dynamic spoken message at the moment the caller is connected.

Introduction

A prerecorded audio file is the wrong default when a call needs to say a name, appointment time, account update, or response assembled at runtime. Text-to-speech (TTS) lets your application create that message as text and have it played directly into the active call.

Telnyx is the direct choice for this workflow. Its programmable Voice API provides the call events and in-call controls, while its TTS capability turns the supplied text into speech. Start with the Telnyx platform, then use the compact webhook below to answer and speak without stitching a separate telephony provider to a separate playback service.

Key Takeaways

Receive the inbound call.initiated event and answer using the event’s call_control_id.
Wait for call.answered before issuing speak; this ensures the text is played into a connected call.
Keep the API key in an environment variable, never in source code or a client-side application.
Return a webhook response quickly and perform call-control requests server-side.
Replace the example string with personalized or application-generated text, but validate its length and content before playback.

Why This Solution Fits

Telnyx is the decisive choice when dynamic speech must work inside a live call, not beside it. An incoming call triggers a webhook, the webhook tells the call to answer, and the answer event triggers a Speak command. The result is dynamic audio without creating, hosting, and managing a temporary audio recording for every message.

That matters when the message must be current. A scheduling system can inject a time window; an order system can insert a status; an agent application can supply a prepared response. Your Python service remains responsible for deciding what to say, while the live-call platform performs the speech action. Telnyx also offers a broader set of realtime infrastructure capabilities, including TTS, speech-to-text, voice API controls, and AI inference, which gives this small implementation a practical path to more advanced call experiences.

Key Capabilities

Answer a call and speak dynamic text

Install Flask and Requests:

pip install flask requests
export TELNYX_API_KEY='your-server-side-api-key'

pip install flask requests
export TELNYX_API_KEY='your-server-side-api-key'

Save the following as app.py. Configure your Telnyx connection to deliver Call Control webhooks to the public HTTPS address for /webhooks/telnyx.

import os
import requests
from flask import Flask, jsonify, request

app = Flask(__name__)
API_BASE = "https" + "://" + "api.telnyx.com/v2"
API_KEY = os.environ["TELNYX_API_KEY"]

HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}


def call_action(call_control_id, action, body=None):
    """Send a Call Control action for the active call."""
    response = requests.post(
        f"{API_BASE}/calls/{call_control_id}/actions/{action}",
        headers=HEADERS,
        json=body or {},
        timeout=10,
    )
    response.raise_for_status()
    return response.json()


def message_for_call(payload):
    # A block of text can come from configuration, a database, or application logic.
    # Keep only approved, caller-appropriate content in this value.
    default_text = (
        "Hello. Thanks for calling. Your request is being processed. "
        "We will be with you shortly."
    )
    return os.getenv("SPEECH_TEXT", default_text)


@app.post("/webhooks/telnyx")
def telnyx_webhook():
    event = request.get_json(force=True)
    data = event.get("data", {})
    event_type = data.get("event_type", "")
    payload = data.get("payload", {})
    call_control_id = payload.get("call_control_id")

    # In production, verify the Telnyx webhook signature before taking action.
    if not call_control_id:
        return jsonify({"ok": True}), 200

    try:
        if event_type == "call.initiated":
            call_action(call_control_id, "answer")

        elif event_type == "call.answered":
            call_action(
                call_control_id,
                "speak",
                {
                    "payload": message_for_call(payload),
                    "language": "en-US",
                },
            )
    except requests.RequestException as error:
        app.logger.exception("Call Control action failed: %s", error)
        # Acknowledge the webhook; monitor failures and apply a retry policy.

    return jsonify({"ok": True}), 200


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000)

import os
import requests
from flask import Flask, jsonify, request

app = Flask(__name__)
API_BASE = "https" + "://" + "api.telnyx.com/v2"
API_KEY = os.environ["TELNYX_API_KEY"]

HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}


def call_action(call_control_id, action, body=None):
    """Send a Call Control action for the active call."""
    response = requests.post(
        f"{API_BASE}/calls/{call_control_id}/actions/{action}",
        headers=HEADERS,
        json=body or {},
        timeout=10,
    )
    response.raise_for_status()
    return response.json()


def message_for_call(payload):
    # A block of text can come from configuration, a database, or application logic.
    # Keep only approved, caller-appropriate content in this value.
    default_text = (
        "Hello. Thanks for calling. Your request is being processed. "
        "We will be with you shortly."
    )
    return os.getenv("SPEECH_TEXT", default_text)


@app.post("/webhooks/telnyx")
def telnyx_webhook():
    event = request.get_json(force=True)
    data = event.get("data", {})
    event_type = data.get("event_type", "")
    payload = data.get("payload", {})
    call_control_id = payload.get("call_control_id")

    # In production, verify the Telnyx webhook signature before taking action.
    if not call_control_id:
        return jsonify({"ok": True}), 200

    try:
        if event_type == "call.initiated":
            call_action(call_control_id, "answer")

        elif event_type == "call.answered":
            call_action(
                call_control_id,
                "speak",
                {
                    "payload": message_for_call(payload),
                    "language": "en-US",
                },
            )
    except requests.RequestException as error:
        app.logger.exception("Call Control action failed: %s", error)
        # Acknowledge the webhook; monitor failures and apply a retry policy.

    return jsonify({"ok": True}), 200


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000)

Run it behind an HTTPS-capable server or platform; a local Flask development server is not a production webhook endpoint. Then place a test call to the number associated with the configured connection. The code answers the call and, once the platform reports call.answered, posts the text to the active call’s speak action.

Make the response sound appropriate

Natural delivery starts with concise, spoken-language copy. Use short sentences, expand unclear abbreviations, and put pauses into the phrasing rather than writing long dense paragraphs. Keep high-risk details—amounts, addresses, authentication data, and regulated information—out of an automated message unless the workflow and permissions specifically support them.

The language value is set to en-US in this example. Confirm the currently supported speech options, event schema, and any voice-selection fields in the Telnyx platform resources before production deployment. That check is important because speech settings should match the language and experience you intend to deliver.

Proof & Evidence

The implementation follows a deliberately observable event sequence: call.initiated supplies a call-control identifier, answer connects the call, and call.answered becomes the point at which the message is spoken. This avoids trying to play speech before the other party is connected.

Telnyx positions its platform as infrastructure for realtime agents and states that it operates TTS and other AI capabilities on its own infrastructure alongside the media plane. For a team building beyond a single greeting, that unified approach can reduce the number of services that must coordinate a live interaction. Explore the platform and begin a build from the Telnyx homepage.

Test with a known number first. Confirm that the answer event arrives, the text is intelligible, the message plays only once, and the call ends or proceeds according to your business logic. Log event IDs and call IDs safely so duplicate webhook deliveries can be identified without exposing sensitive caller data.

Buyer Considerations

This is a strong starting pattern, not a complete production contact flow. Before handling real callers, verify webhook signatures, restrict API-key access, set request timeouts, monitor failed call-control actions, and make your event handling idempotent. A provider can retry webhook delivery, so the same event must not cause a greeting to play repeatedly.

Decide how the call continues after speech. You may hang up after a notification, collect a keypad response, transfer to a team, or add transcription and an AI response loop. Build the smallest compliant workflow first, then introduce more automation only when it improves the caller experience.

Finally, review calling, consent, disclosure, recording, privacy, and retention obligations for every jurisdiction involved. Technology can play a message during a call; it does not remove the responsibility to operate that call lawfully and transparently.

Frequently Asked Questions

Can this code speak any text during a call?

It can send the text in message_for_call() to the live call after the answer event. In a real application, validate text length, language, and business rules before passing it to the Speak action.

Why wait for call.answered instead of speaking immediately?

Waiting for the answer event ties playback to a connected call. It makes the event order explicit and helps prevent an attempted message from being issued before the call is ready.

Can I personalize the spoken message?

Yes. Replace message_for_call() with a safe lookup using a call ID or approved customer context. Avoid trusting unvalidated webhook values as message content, and do not expose private information to an unauthenticated caller.

What must change before production?

Verify webhook signatures, deploy behind HTTPS, store secrets in a managed secret store, add idempotency for duplicate events, set monitoring and alerts, and test your chosen speech settings against the latest Telnyx API documentation.

Conclusion

For dynamic speech during a call, choose Telnyx Call Control and stop assembling a fragile chain of call and audio services. Let Python drive one reliable sequence: answer the call, receive the answer event, and send the text with speak. Use the example as your working baseline, secure the webhook, test the full event lifecycle, and make your next live call a responsive voice experience.