Loading…
Twilio
Cloud communications platform providing APIs and services for messaging, voice, email, authentication, and customer engagement.
- 94 posts summarised
- latest
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.
From their blog
Latest articles
From AI Agent to Human Agent: ElevenLabs Call Handoffs with Twilio
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.
Integrate Deepgram Flux with Twilio's Conversation Relay
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.
Holiday email marketing best practices for 2026 (and beyond)
Holiday email marketing carries higher volume and stakes during the seasonal shopping period, making planning, deliverability, personalization, and post-holiday retention central concerns. The guide recommends warming sending volume before Black Friday and Cyber Monday, increasing it by only 25–40% at a time to avoid sudden mailbox-provider signals. It also calls for a calendar with one or two lower-volume days each week, list hygiene, segmentation, testing, and journey-driven campaigns that account for shipping and fulfillment constraints. For holiday-season signups, the post-holiday process uses sign-up date or source cohorts, monitors open and click rates, and can reduce frequency, run re-engagement campaigns, or suppress addresses after 30–60 days without engagement. Examples and templates emphasize concise, value-driven content, specific offers, and personalization such as location or past purchases.
Choosing a low-latency infrastructure layer for conversational AI
Conversational AI call-center latency can feel like dead air, and the delay may come less from LLM inference than from the infrastructure moving audio among telephony, media servers, ASR, the agent, and TTS. The described approach uses a unified voice path: ConversationRelay provides a WebSocket API to stream live call audio, handle speech-to-text and text-to-speech in one connected pipeline, connect with a backend agent, and support barge-in. It is model-agnostic, allowing teams to retain their LLM, knowledge bases, AI tools, and third-party voice providers, while Conversation Orchestrator, Conversation Memory, and Agent Connect address context and integration. Twilio’s internal benchmarks report median latency below 0.5 second and below 0.725 second at the 95th percentile, though relevance and context also matter alongside speed.
What is bring your own LLM (BYO LLM)?
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.
Build a Video Chat App with ASP.NET Core and Angular using Twilio Video
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.
4 must-ask questions before you delegate to your AI agent
Automation roadmaps that prioritize ticket volume and low complexity can improve containment while lowering customer satisfaction when customers did not want a task automated. The post proposes four screening questions: how reversible a mistake is, whether the task touches money, health, or identity, whether the customer needs a transaction or to be heard, and whether the AI can access the necessary context. It cites a Twilio survey of 7,652 consumers, including 80% comfortable with appointment or reservation scheduling and 60% unwilling to have AI handle a medical inquiry. Tasks that fail the test can be split between AI and people: AI gathers information, verifies identity, retrieves history, and drafts a recommendation before a human decides, with Twilio Conversation Orchestrator handing conversation history and profile to Twilio Flex. The recommendation is to start with tasks where errors are relatively cheap and the data is available.
How to disclose AI to customers without killing the conversation
Customer service teams may avoid disclosing AI because they fear customers will leave, but the post argues that unclear or delayed disclosure creates more frustration than honesty. It recommends a short first-turn greeting that says “AI,” explains what the agent can do, and offers an immediate route to a human, with renewed disclosure when a conversation moves to SMS or voice. Web chat, SMS, and voice examples show how to pair disclosure with an exit, while voice should disclose before the caller explains the issue and leave a pause. The post identifies burying the disclosure, using ambiguous labels, apologizing, over-explaining, and omitting escalation as failure modes. It proposes checking Twilio Conversation Intelligence transcripts alongside containment and escalation rates to assess wording changes, citing research on customer expectations and bypass behavior.
When AI takes the wheel: The rise of invisible identity intelligence in 2026
Point-in-time authentication treats an initial password, MFA, or passkey check as sufficient trust for the rest of a session, leaving post-login account takeovers, session hijacking, and risky API actions insufficiently evaluated. The proposed model replaces this front-door assumption with continuous context evaluation using passive telemetry such as network, telecommunications, device, behavioral, and transaction signals, then intervenes when risk scores or policy thresholds rise. For AI agents, delegated authority sets temporal, monetary, and API limits through short-lived credentials, while Know Your Agent lineage links execution to the authorizing human and deploying enterprise. High-impact actions can trigger human checkpoints through SMS, push, or voice channels, while immutable logs, transparent scoring, tenant isolation, and session lineage support auditability and compliance. The resulting architecture aims to keep low-risk autonomous work unobtrusive while making sensitive operations controllable and provable.
Complete guide to sending email to Google: Rules, signals & setup
Sending email to Google requires understanding differences between consumer Gmail and Google Workspace, plus the authentication and reputation signals used by Google’s filtering systems. The guide says SPF and DKIM are required for all senders, while DMARC is required for senders exceeding 5,000 messages per day to Google inboxes; it also gives a bounce example for missing alignment. It recommends keeping user-reported spam below 0.1%, never reaching 0.3%, and providing one-click unsubscribe handling. Google Postmaster Tools reports compliance, spam rate, authentication success, and delivery errors, while the Feedback-ID header enables aggregate complaint analysis by campaign or sender ID. Workspace administrators can apply additional filters, so successful delivery to Gmail does not guarantee placement in a corporate Workspace inbox.
How to Approve Real Users and Block Fake Accounts at Sign Up with Lookup and Verify in PHP
The tutorial shows how to combine Twilio Lookup and Verify in a PHP sign-up flow that screens phone numbers before sending an OTP. It starts with Line Type Intelligence to accept mobile numbers, optionally checks reachability with Line Status, and uses Identity Match to compare submitted first and last names against authoritative sources without revealing underlying data. If those checks pass, the application sends a six-digit verification code and validates it through a Verify service. The provided implementation uses PHP 8.5, Slim, Twig, Monolog, and the Twilio REST client, with environment flags controlling optional checks and logs recorded in data/app.log. Testing covers mobile, toll-free, VoIP, and name-mismatch cases, while the pricing discussion recommends ordering cheaper checks before more expensive Identity Match and Verify calls.
Your customers don't hate AI — they hate you lying about it
Twilio research reports a major gap between brands’ and consumers’ accounts of AI-agent disclosure: 81% of brands say agents identify themselves immediately, while only 22% of consumers report that experience. Teams may treat a system-prompt line, widget label, or one-time channel message as disclosure, even though customers can miss it or encounter a different experience on SMS or voice. Recommended practice includes naming “AI agent” at the first turn, repeating disclosure across channels, explaining accessible data and decision logic, and offering an immediate route to a person. It also recommends checking transcripts rather than trusting configuration, using conversation analysis to verify whether disclosure fired. Research cited says 76% expect identification at the start, 49% want data-access transparency, and 54% trust AI more when its logic is explained.
How to Confirm Phone Number Ownership with Lookup Identity Match
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.
Build a Video API with Twilio Programmable Video, Node.js, TypeScript, and Express
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.
How to Approve Real Users and Block Fake Accounts at Sign Up with Lookup and Verify
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.
How to Confirm Phone Number Ownership with Lookup Identity Match in PHP
The post presents a PHP signup flow that uses Twilio Lookup Identity Match to confirm whether submitted identity details correspond to a phone number and to reduce signup fraud. Identity Match performs a zero-knowledge match against authoritative sources such as mobile carrier records, using supplied fields including names, addresses, national IDs, or dates of birth. The implementation builds on a Slim PHP project, adds Twig form handling and the Twilio REST client, then sends the phone number, first name, and last name through the Lookup API. Registration succeeds only when the number is valid and both names return exact_match or high_partial_match; otherwise, the form displays an instruction to provide information for a phone number the user owns.
How to Approve Real Users and Block Fake Accounts at Sign Up with Lookup and Verify in C#
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.
How to Use Svelte and Go to Build a Video Chat App
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.
How to Confirm Phone Number Ownership with Lookup Identity Match in Python
The tutorial shows how to use Twilio Lookup Identity Match in Python to confirm that signup information is associated with a phone number and reduce signup fraud. It builds a Flask application that accepts an E.164-formatted number, first name, and last name, then calls the Lookup API with fields="identity_match" and the supplied identity attributes. The response exposes statuses including exact_match, high_partial_match, no_match, and no_data_available; the example accepts a result only when the number is valid and both names are exact or high partial matches. The implementation covers project setup with Flask, twilio, and python-dotenv, environment-based credentials, an intl-tel-input form, and frontend handling for success and failure messages. It also notes that Identity Match can use combinations of name, address, national ID, or date of birth, and points to other Lookup packages such as Line Type Intelligence and SIM swap detection.
Why 78% of customers try to bypass your AI agent
Twilio research cited in the post finds that 78% of consumers have tried to bypass an AI agent to reach a human, while 63% want easy escalation and only 47% of brands provide it. The reported causes are unclear AI disclosure, discomfort with high-stakes tasks, and prior failures: 90% of tested consumers misidentify text-based AI, 80% report a negative AI experience, and failed attempts add 81 seconds before escalation. Consumers are most comfortable with scheduling and reservations, returns and exchanges, and concert seat selection, but pull back on medical inquiries, payments, and loan applications. The proposed operating model combines routine automation with clear disclosure, obvious escalation, persistent customer memory, and real-time detection of sentiment and escalation risk. It argues that trust, rather than wholesale replacement, should determine how humans and AI divide customer-service work.
Topics they write about
All topics →Weekly digest
The best engineering reads, once a week.