TL;DR: Twilio now supports typing indicators for WhatsApp. When your backend takes a few seconds to generate a response, you can show users that something's happening instead of leaving them staring at a silent chat.

This guide covers what's new, how to implement it, and when you should (and shouldn't) use it.

What's Changed

As of October 2025, Twilio's WhatsApp API includes a new endpoint for triggering typing indicators. When you call it, two things happen:

1. The message you're responding to gets marked as read (blue checkmarks)
2. A typing animation appears in the user's WhatsApp client

The indicator disappears when you send your actual response or after 25 seconds, whichever comes first.

This is currently in Public Beta, which means a few things: the API could change before GA, it's not covered by Twilio's SLA, and it's not HIPAA-eligible or PCI-compliant. Don't use it in healthcare or payment workflows.

Why This Matters

Users hate silence. When someone sends a message to your support bot or order lookup system, every second of no response feels like something broke. Research consistently shows that perceived wait times drop significantly when users see visual feedback that something's happening.

Typing indicators solve this by mimicking human conversation patterns. Your AI chatbot might need 3-4 seconds to process a query, call an external API, and format a response. Without a typing indicator, that gap feels like an eternity. With one, it feels like talking to someone who's thinking.

This is especially valuable for:

AI chatbots and LLM-powered responses where inference time creates noticeable delays. GPT-style responses don't generate instantly, and users need to know you haven't dropped the connection.

Order status lookups that query external systems. Database calls, inventory checks, shipping API requests, all of these take time.

Customer support workflows where context retrieval or human handoff decisions happen server-side.

Multi-step automations where you're coordinating between services before responding.

How It Works

The API is straightforward. You POST to Twilio's typing indicator endpoint with the message ID you're responding to:

curl -X POST https://messaging.twilio.com/v2/Indicators/Typing.json \
  -u $TWILIO_ACCOUNT_SID:$TWILIO_AUTH_TOKEN \
  --data-urlencode "messageId=SMaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" \
  --data-urlencode "channel=whatsapp"

Two required parameters:

Success returns:

{
  "success": true
}

That's it. No complex setup, no additional webhooks to configure.

Implementation: Node.js Example

Here's a practical pattern for a webhook that handles incoming WhatsApp messages and uses typing indicators for slower responses:

const express = require('express');
const axios = require('axios');

const app = express();
app.use(express.urlencoded({ extended: true }));

const accountSid = process.env.TWILIO_ACCOUNT_SID;
const authToken = process.env.TWILIO_AUTH_TOKEN;

async function sendTypingIndicator(messageSid) {
  try {
    await axios.post(
      'https://messaging.twilio.com/v2/Indicators/Typing.json',
      new URLSearchParams({
        messageId: messageSid,
        channel: 'whatsapp'
      }),
      {
        auth: {
          username: accountSid,
          password: authToken
        }
      }
    );
  } catch (error) {
    console.error('Failed to send typing indicator:', error.message);
  }
}

app.post('/webhook/whatsapp', async (req, res) => {
  const incomingMessage = req.body.Body;
  const messageSid = req.body.MessageSid;
  const from = req.body.From;

  // Trigger typing indicator immediately
  await sendTypingIndicator(messageSid);

  // Do your slow processing here (LLM call, database lookup, etc.)
  const response = await generateResponse(incomingMessage);

  // Send the actual reply
  await sendWhatsAppMessage(from, response);

  res.status(200).send();
});

Implementation: Python Example

Same pattern in Python using the requests library:

import os
import requests
from flask import Flask, request

app = Flask(__name__)

account_sid = os.environ['TWILIO_ACCOUNT_SID']
auth_token = os.environ['TWILIO_AUTH_TOKEN']

def send_typing_indicator(message_sid):
    try:
        response = requests.post(
            'https://messaging.twilio.com/v2/Indicators/Typing.json',
            data={
                'messageId': message_sid,
                'channel': 'whatsapp'
            },
            auth=(account_sid, auth_token)
        )
        response.raise_for_status()
    except requests.RequestException as e:
        print(f'Failed to send typing indicator: {e}')

@app.route('/webhook/whatsapp', methods=['POST'])
def handle_whatsapp():
    incoming_message = request.form.get('Body')
    message_sid = request.form.get('MessageSid')
    from_number = request.form.get('From')

    # Trigger typing indicator immediately
    send_typing_indicator(message_sid)

    # Do your slow processing here
    response_text = generate_response(incoming_message)

    # Send the actual reply
    send_whatsapp_message(from_number, response_text)

    return '', 200

When to Use Typing Indicators

Use them when:

• Your response takes more than 2-3 seconds to generate
• You're calling external APIs or LLMs
• You're performing database queries or complex lookups
• Users might otherwise think the bot is broken

Don't use them when:

• Your responses are instant (sub-second)
• You're not actually going to respond (the indicator sets expectations)
• You're in a HIPAA or PCI context (not supported in beta)
• You're sending rapid-fire messages where indicators would flash annoyingly

The 25-second timeout is a hard limit. If your processing takes longer, the indicator vanishes and you're back to silence. For operations that might exceed this, consider sending a preliminary acknowledgment message before diving into the heavy processing.

Beta Limitations

A few things to keep in mind during Public Beta:

No SLA coverage. If the feature breaks, Twilio support won't prioritize it. Build graceful degradation into your error handling.

Not HIPAA/PCI compliant. If you're in healthcare or handling payment data, skip this feature until GA (and verify compliance then).

API may change. The endpoint, parameters, or behavior could shift before general availability. Keep an eye on Twilio's changelog.

Test thoroughly. Beta features can behave inconsistently. Validate in your staging environment before production.

What's Next for WhatsApp Business Messaging

Typing indicators are part of a broader trend: business messaging is getting more conversational. The WhatsApp Business Platform has been steadily adding features that make automated interactions feel more human, including read receipts, reactions, and now typing indicators.

Meta's Conversations 2025 conference in Miami this past July signaled where things are heading. They announced voice and video calling on the WhatsApp Business Platform (now generally available), letting customers tap a button to call directly from a chat and businesses call customers who've opted in. Business AIs are rolling out to more markets, and Status ads are coming to Ads Manager.

Looking ahead to 2026, expect AI-enabled voice support to move from experimental to production-ready. Meta has been clear that they're building toward AI agents that can handle voice interactions, not just text. For developers, this means planning for richer, multi-modal conversations where typing indicators are just one piece of a larger conversational toolkit.

For developers working directly with Meta's API rather than through Twilio, the WhatsApp Cloud API also supports typing indicators with similar functionality.

Using Typing Indicators with Courier

If you're building WhatsApp notifications through Courier, you can layer typing indicators into your existing workflows. Courier handles the orchestration and routing logic while Twilio provides the WhatsApp delivery, and adding a typing indicator trigger before slow message sequences becomes a simple addition to your automation flow.

This is especially useful for complex workflows where messages might depend on data from multiple sources, AI-generated content, or conditional routing. Rather than managing typing indicator timing manually across every integration point, you can coordinate it through Courier's automation engine alongside your existing notification logic.

The pattern is straightforward: when Courier receives a trigger that will result in a WhatsApp message with processing delay, fire the typing indicator call before kicking off the content generation. Your users see the typing animation while the real work happens in the background.

For teams already using Courier with Twilio for multi-channel notification orchestration, this fits naturally into your existing architecture without adding another integration to maintain.

WhatsApp typing indicators are available now in Twilio's Public Beta. Check Twilio's documentation for the latest API details.