Loading…
Topic
61 posts about Twilio. Every summary links to the original.
See the idea
The Branded Calling trust chain, layer by layer: how identity, STIR/SHAKEN attestation, Rich Call Data, and carrier delivery combine so a verified brand name reaches the recipient's screen.
The Good Stuff
Paid picks we use ourselves. Links carry a referral code — a subscription through one earns us a commission at no extra cost to you.
Newest first
This tutorial shows how to build an AI voice assistant that answers phone calls using Twilio Programmable Voice, Twilio Media Streams, OpenAI's GPT-Live-1, and Node.js. GPT-Live-1 acts as the speech-to-speech model for listening, talking, and handling interruptions, while the delegated gpt-5.6-terra model handles deeper reasoning and tool use. The implementation uses a Fastify server with WebSocket support, dotenv configuration, a marin voice, and separate prompts for the voice and backend roles. Callers can request a city's top headline through the custom get_top_headline function or ask factual questions through OpenAI's hosted web_search tool. The guide exposes port 5050 with ngrok, points a Twilio number at an /incoming-call webhook, and concludes that the working example fits in under 200 lines.
This tutorial shows how to build an outbound AI voice agent that uses Twilio Programmable Voice and Media Streams to call a permitted phone number, rather than waiting for inbound calls. It connects the call to GPT-Live-1 in the OpenAI API through a Node.js server, with Fastify, ws, dotenv, and the Twilio helper library handling the application and relay. The implementation reads the destination from a --call flag, validates E.164 formatting, exposes the server through a public tunnel, and uses environment variables for credentials and the calling number. Owlie identifies itself as an AI assistant, retrieves a callback note with get_callback_reason, delegates factual questions to hosted web_search, and can be interrupted during speech. The completed demo rings the chosen number, explains why it is calling, and can return random callback notes or web-searched answers, while the tutorial stresses verified numbers, model access, and outbound-calling compliance.
This reference integration connects an ElevenLabs voice agent to Twilio Programmable Voice, enabling escalation from automated support to a human when a conversation becomes complex, sensitive, or unresolved. Twilio retains ownership of the original inbound call while ElevenLabs conducts the real-time conversation; an escalate_to_human webhook tells Twilio to update that parent Call SID with new TwiML. In the Flex example, Enqueue sends the caller into a TaskRouter workflow, creating a voice task with intent and summary context, while the Call SID and metadata such as direction and phone numbers travel into ElevenLabs as dynamic variables for the handoff. The blueprint describes Studio-owned routing, direct TaskRouter or Flex routing, and custom TwiML destinations; Conversation Memory and Conversation Intelligence are optional additions, and the implementation is explicitly a proof of concept rather than a production drop-in.
Twilio's ConversationRelay connects phone calls to an AI stack while handling speech-to-text, text-to-speech, and the WebSocket session, leaving application code focused on the LLM and conversation logic. This tutorial updates a Node.js ConversationRelay application to use Deepgram Flux, which combines transcription and turn detection and is described as reducing response latency by up to 200–600 milliseconds and false interruptions by around 30 percent. It walks through cloning a Fastify demo, exposing it with ngrok, configuring environment variables, and adding Flux settings to the ConversationRelay TwiML, including eotThreshold, speechTimeout, and ignoreBackchannel. The supplied configuration uses an end-of-turn threshold of 0.8, a 3,000-millisecond speech timeout, and enabled backchannel ignoring, while the tutorial also explains partial prompts, smart formatting, and recognition hints.
Bring your own LLM (BYO LLM) is an architecture in which teams choose the model powering their AI agents while a platform supplies communication infrastructure. The division leaves model selection, prompts, reasoning logic, tool definitions, and called systems with the team, while channels, conversation context, audio streaming, identity resolution, and human escalation remain with the platform. The post explains why bundled models create quality, migration, compliance, and cost-control constraints, including the inability to route simple interactions to smaller models and complex work to frontier models. It describes adding a third-party model to an existing contact center through middleware, a shared message handler, tools and knowledge, channel registration, and context-preserving handoff. Twilio Agent Connect is presented as a self-hosted Python and TypeScript SDK under the MIT License, with voice streaming and integrations for existing contact-center workflows.
This tutorial builds a small group video chat application with an ASP.NET Core Web API and Angular single-page app using Twilio Programmable Video. The API binds typed Twilio credentials, mints short-lived access tokens locally with the API Secret, reads active rooms through the Twilio REST API, and pushes room-list changes over SignalR instead of browser polling. The Angular client uses the twilio-video library to capture camera and microphone media, connect to rooms, render participants, and provide device selectors. Local development runs the API alongside ng serve, while a Release MSBuild target runs npm ci and npm run build so dotnet publish places the SPA in the API's wwwroot. The resulting local test demonstrates a two-participant call and a live active-room count that updates when someone joins or leaves.
The tutorial shows how to use Twilio Lookup Identity Match to confirm that a person is linked to a submitted phone number and reduce sign-up fraud. It describes a zero-knowledge match against authoritative sources such as mobile carrier records, with possible use during sign-up, login, account changes, or checkout. The implementation starts from an international telephone input project, collects first and last names alongside an E.164 phone number, and passes them to the Lookup API with the identity_match field; the response exposes per-field statuses and a summary score. The sample JavaScript treats the check as successful when the phone is valid and both names are exact or high partial matches, then displays the result, while the post also notes approval requirements outside the US, test parameters, and alternative Lookup packages.
This tutorial builds an Express API for creating and managing Twilio Programmable Video rooms with Node.js and TypeScript. It sets up a project with Express, TypeScript 5, ts-node, node-dev, dotenv, and the Twilio Node.js helper library, while requiring Node.js 20 or 22 LTS. Twilio account credentials are stored in environment variables loaded from .env, which is excluded through .gitignore. The TypeScript configuration compiles strict CommonJS source from src into build and targets ES5; routes call the Rooms API to create rooms and complete them by changing status to completed, disconnecting connected participants. The result is a server-side room-management foundation, with access-token issuance identified as the next step for browser or mobile participants.
Fake accounts and signup fraud can undermine onboarding, so the tutorial builds a Node.js flow that collects a user's name and phone number. It combines Twilio Lookup and Verify through four progressively intense checks: line type, line status, identity match, and SMS OTP possession. The implementation blocks landline, nonfixed VoIP, toll-free, and pager numbers, checks submitted first and last names against authoritative sources using exact_match or high_partial_match, and sends an OTP only after the lookup steps pass. Line status is optional in the example because access is in Private Beta, while the project uses Express, EJS, and environment variables for its Node.js setup. It also demonstrates expected outcomes for mobile, blocked, and mismatched inputs, then notes that pricing varies by country.
Fake accounts and fraudulent sign-ups motivate a C# onboarding flow that screens phone numbers before sending an OTP. It combines Twilio Lookup line type intelligence, optional line status checks, and Identity Match with Twilio Verify phone verification. The pipeline rejects landline, nonfixed VoIP, toll-free, and pager types, requires first- and last-name results of exact_match or high_partial_match, and can reject lookup failures or mismatches. The post supplies a .NET 9 project setup, environment variables, MVC files, and service code for starting and checking verification. It reports example logs for a mobile number with active status and exact name matches, demonstrates blocked toll-free or VoIP testing, and notes that Lookup and Verify pricing varies by package and country.
The tutorial builds a video chat application with a Svelte single-page frontend and Go REST API, using Twilio Video for room-based calls. Users enter a room name, the backend validates it, mints a Twilio Access Token with a VideoGrant, and the frontend uses that token to connect and attach local and remote video tracks. The backend loads credentials from .env.local, assigns each participant a random crypto/rand identity, enables CORS, and serves requests on port 8000; room names shorter than six characters receive a 400 response. The frontend uses Vite, the Twilio Video JavaScript SDK, and iziToast, while testing involves running both servers and joining the same room in two browser tabs. The completed app handles video communication without custom permission, real-time communication, or data-streaming code.
This tutorial builds a browser-based video chat application using Python, Flask, vanilla JavaScript, HTML, CSS, and Twilio Programmable Video. It adds text chat through Twilio Conversations and screen sharing, allowing participation on modern desktop and mobile browsers without installed software. The implementation covers Twilio account and API-key setup, environment variables, a Python virtual environment, client-side event handlers, and ngrok, which exposes the local Flask server through an HTTPS public URL for testing on other devices. The refreshed project targets Flask 3.x, twilio-python 9.x, Twilio Video JS 2.35.x, and Twilio Conversations classic JS 2.x, and the completed flow supports live calls, screen sharing, and text chat. Participants must use unique names because Twilio identifies them by token identity.
Published in August 2026, this guide compares eight conversational AI platforms amid rapid market consolidation and acquisitions including NiCE’s roughly $955 million purchase of Cognigy. It defines the category as software for building, deploying, and operating agents across voice and messaging, then distinguishes vendor-managed services that own reasoning from infrastructure providers that carry conversations while teams own the reasoning. The evaluation criteria include model flexibility, voice and messaging parity, deployment control, cross-channel context, human handoff, pricing, and integration depth. Twilio is presented as an infrastructure layer for teams choosing their own models, with ConversationRelay, Agent Connect, Conversation Orchestrator, Conversation Memory, and Flex supporting channels, continuity, and escalation; other entries include Google Conversational Agents, Kore.ai, and NiCE Cognigy. The guide argues that portable models and conversation data will matter as the conversation layer separates from agent reasoning.
This tutorial builds a basic browser-based video conferencing application with JavaScript, HTML, and CSS using Twilio Programmable Video. It targets desktop and mobile web browsers, requiring no installed client, and uses the Twilio Serverless platform to provide hosting and a public URL. The setup creates a Twilio Serverless project, configures ACCOUNT_SID, API_KEY_SID, and API_KEY_SECRET in .env, runs npm start locally, and deploys with twilio serverless:deploy; the client manages joining, participant video streams, disconnection, and participant counts. After deployment, users can open the generated index.html URL on separate devices or share it with others to see participants appear dynamically, while the conclusion notes additional Twilio Video capabilities such as recording, custom data tracks, screen sharing, and virtual backgrounds.
The post argues that the long-standing trade-off between security and seamless user experience is a false choice, especially as autonomous AI agents act across systems. High-friction measures such as passwords, CAPTCHAs, and one-time login checks can create insecure credential reuse and fail to govern over-permissioned agents or risks that emerge during a session. It proposes invisible, continuous risk evaluation using device, network, phone, email, communication, and behavioral signals, with event-triggered verification when an agent requests a consequential action. The approach also separates human authentication from agent identity and Know Your Agent (KYA), which define delegated authority, contextual rules, and time-bounded permissions while linking an agent to its deploying entity. Twilio is presented as a unified trust layer combining customer data, security intelligence, AI governance, and communication channels; the conclusion is that adaptive controls can protect users while making security largely invisible.
This webinar addresses the gap between impressive voice AI demos and reliable production deployments, focusing on global rollout barriers such as spam-flagged outbound calls, legal delays, latency, and custom integration work. It presents Twilio Voice and AI through the Guinness Price Index case, alongside reported examples from Docplanner and audibene, whose use of the Twilio platform is said to halve costs, double booking efficiency, and improve inbound reachability by 30 percent. A developer demonstration shows how Twilio Skills and an AI coding agent configure an initial setup, while an open-standard Model Context Protocol (MCP) Server and Twilio Agent Connect SDK replace growing custom glue code. It also covers Conversation Relay for real-time audio, Conversation Memory and Conversation Orchestrator for AI-to-human handoffs, and connections to privately hosted models to retain cloud and roadmap control. The session frames compliance, privacy, personalisation, and vendor lock-in as operational concerns in scaling voice AI.
Video calling can add direct, personal communication to customer and patient interactions without moving conversations to a third-party app or website. The post outlines an integration path based on choosing a platform, selecting development-specific SDKs, and either building a custom application or deploying and adapting an open-source one. Twilio is presented as a cloud communications platform offering APIs, SDKs, reference apps, and documentation, with SDKs for JavaScript, Android, and iOS; listed build examples also use Svelte, Go, Python, ASP.NET Core, Angular, Node.js, TypeScript, and Express. Open-source options provide features such as screen sharing and network-condition monitoring, while Twilio Video supports branded virtual backgrounds and layouts, but the source does not report implementation results.
Passwordless authentication replaces passwords with one-time codes delivered by SMS, and this tutorial builds a Rust app around that flow. The app uses Twilio Verify for OTP generation and validation, with GET and POST routes at "/" for collecting a phone number and at "/verify" for entering the received code. It sets up a Cargo project with Axum, Handlebars templates, sessions, dotenvy configuration, and the rustlio Twilio client, while environment variables hold the Account SID, Auth Token, and Verify Service SID. The implementation also serves HTML forms and static assets, with verification status rendered as a success or error message. Running cargo run starts the server on port 8080, where users can submit a number, receive an SMS, and see whether the verification code is valid.
Passwordless authentication with PHP and Twilio Verify replaces password entry with a phone-based one-time passcode flow, intended to reduce password-related risk and simplify sign-in. The tutorial uses a Slim base project, Composer dependencies, Dotenv configuration, a Twilio Verify Service SID, and PHP session state to support the flow. Users submit a phone number through the root route; the server asks Twilio Verify to send an SMS OTP, redirects to /verify, and checks the submitted code through the verification endpoint. The example’s verification form restricts input to a six-digit numeric value, and the application reports whether verification succeeded or failed after testing locally with composer serve on port 8080.
The tutorial builds a passwordless authentication flow in Go that uses Twilio Verify to send and validate one-time passwords (OTPs) by SMS, avoiding the need for users to manage passwords. It defines a small net/http API with GET and POST handlers for "/" and "/verify": the first collects a mobile number and starts verification, while the second accepts the received code and displays the result. The setup covers Go 1.23 or later, module dependencies, dotenv configuration for the Twilio Account SID, Auth Token, and Verify Service SID, plus session handling for the phone number. The verification check calls Twilio's CreateVerificationCheck() and renders success or failure using templates; running go run main.go starts the server on port 8080 for testing.
The best engineering reads, once a week.
