> ## Documentation Index
> Fetch the complete documentation index at: https://docs.airmdr.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Twilio

> Connect Twilio to AirMDR to send SMS notifications through a Twilio Messaging Service. This guide explains how to obtain your Account SID, configure the Username and Password, retrieve the Messaging Service SID, and set up the AirMDR connection.

> **Purpose**
>
> The Twilio integration enables you to send an SMS message to one phone number at a time from AirMDR.
>
> Use this integration to:
>
> * Notify an on-call responder about a security incident.
>
> * Send a time-sensitive investigation update.
>
> * Ask a user to review suspicious activity.
>
> > [!NOTE]
> >
> > Each AirMDR connection uses one Twilio account and one Messaging Service. Create separate connections when using different accounts or services.

> **Supported Versions**
>
> | Component | Compatibility |
> | - | - |
> | Messaging Services API | REST API `v1`, used to verify the configured Messaging Service. |
> | Credential region | **United States (US1)**. AirMDR uses Twilio’s US1 API hosts. |
> | Connection verification | Reads the Messaging Service and checks that its account matches the configured Account SID. |
> | Twilio platform | Twilio cloud-hosted Programmable Messaging. |
> | Messages API | REST API version `2010-04-01`. |
> | Sending configuration | A Twilio Messaging Service identified by its `MG` SID. |
> | Authentication | Standard API Key SID and Secret, or Account SID and Auth Token. |
> | AirMDR operation | Outbound SMS to one recipient per skill execution. |
>
> > [!NOTE]
> >
> > The Messages API creates messages under the specified Twilio account. The Messaging Service determines which configured sender to use.

> **Authentication**
>
> AirMDR authenticates to Twilio using **HTTP Basic authentication**. Configure either of the following credential pairs:
>
> | Authentication Method | Username | Password |
> | :- | :- | :- |
> | **Standard API key — recommended for this integration** | API Key SID beginning with `SK`. | API Key Secret generated when the key is created. |
> | **Account credentials — alternative** | Account SID beginning with `AC`. | Auth Token for that account. |
>
> The Username and Password fields contain **API credentials**, rather than the email address and password used to sign in to the Twilio Console. Twilio supports API Key SID and Secret authentication for REST API requests.
>
> A dedicated API key allows you to revoke AirMDR’s credential independently. However, a **Standard** key has broad API access within its account; it is not restricted to the selected Messaging Service. 
>
> > **Role-based access considerations**
> >
> > Use a Twilio account role that permits access to API credentials, phone numbers, and messaging configuration. Twilio’s general **Developer** role provides access to development resources and credentials; **Administrator** and **Owner** roles provide broader account access. Apply your organization’s access policy when assigning roles.
> >
> > The Console role controls what the person configuring the integration can manage. Runtime API requests use the permissions of the credentials saved in AirMDR.

## Pre-requisites

> > [!TIP]
> >
> > An active Twilio account with a paid (upgraded) Twilio account with messaging enabled and sufficient balance to send notifications.
>
> > [!TIP]
> >
> > Twilio Console access to manage API credentials and Messaging Services.
>
> > [!TIP]
> >
> > A Messaging Service containing at least one sender suitable for the destination country.

> [!NOTE]
>
> Running the messaging skill sends a real SMS message and may incur Twilio charges. A message that has been sent cannot be recalled.

> [!NOTE]
>
> Trial accounts have recipient, destination, content, and duration restrictions and are unsuitable for production alerting. Use an upgraded account for AirMDR notifications and complete the applicable sender registration and account compliance requirements.

## Setup Steps

**1. Obtain the Account SID**

1. Sign in to the [Twilio Console](https://console.twilio.com/).
2. Select the account or subaccount that will send messages.
3. Open its home page or account dashboard.
4. On the Console Home page, locate the card named after the selected account and copy its **Account SID**, which begins with `AC`. In the legacy Console, this information appears under **Account Info**.

> [!NOTE]
>
> Twilio displays the Account SID and Auth Token on the Console home page.

> [!NOTE]
>
> Use the account that owns the Messaging Service. When using a subaccount, obtain the credentials and Messaging Service from that same subaccount.

**2. Obtain the Username and Password**

Choose one of the authentication method.\
Option A: Create a Standard API Key\
(or)\
Option B: Use the Account SID and Auth Token

#### Option A: Create a Standard API Key

1. In the Twilio Console, open **Settings → Account settings → API keys & auth tokens**.
2. Select the appropriate **Region**. For example: `United States (US1)`
3. Click **Create API key**.
4. Enter an API key name, such as `AirMDR-SMS-Production`.
5. Select **Standard** as the key type.
6. Click **Next**.
7. Copy the generated **API Key SID** and **Secret**.
8. Store the Secret securely before leaving the page.
9. Select **Got it!**, then click **Finish**.

> [!NOTE]
>
> For the legacy Console,
>
> 1. Open **Admin → Account management → Keys & credentials → API keys & tokens**.
> 2. Click **Create API key**.
> 3. Enter a **Friendly name**.
> 4. Select the Region and **Standard** key type.
> 5. Click **Create**.
>
>    > [!WARNING]
>    >
>    > \*\*Copy the credentials, and acknowledge the confirmation \*\*
>    >
>    > **Save the credentials in an approved Password Manager or Vault.**
>    >
>    > **The Secret is displayed only when the key is created. If it is lost, create a replacement key.**
> 6. Click **Done**.

Enter the following values in AirMDR:

| AirMDR Field | Twilio Value |
| :- | :- |
| **Username** | API Key SID beginning with `SK`. |
| **Password** | API Key Secret. |

> [!TIP]
>
> Create the API key in **United States (US1)**. AirMDR calls Twilio’s US1 API hosts; credentials created in another Region will be rejected.

> [!TIP]
>
> You can also open **API keys & auth tokens** from the bottom of the account card on the Console Home page.

#### Option B: Use the Account SID and Auth Token

1. Open the selected account’s Twilio Console home page.
2. Navigate to **Settings → Account settings → API keys & auth tokens.**
3. Select the **Auth tokens** tab, and locate **Primary auth token**.
4. Click the eye icon to reveal and copy the **Auth Token**.

Enter the following values in AirMDR:

| AirMDR Field | Twilio Value |
| :- | :- |
| **Username** | Account SID beginning with `AC`. |
| **Password** | Auth Token for that account. |

> [!TIP]
>
> You can also manage account credentials through the **API Keys & Tokens** page.

> [!NOTE]
>
> Before rotating an account Auth Token, identify other applications that use it to avoid interrupting their access

**3. Obtain the Messaging Service SID**

Choose one of the  method.\
Option A: Use an Existing Messaging Service\
(or)\
Option B: Create a Messaging Service

> [!NOTE]
>
> If Messaging Services is not visible in the sidebar, use the Twilio Console search to search for **Messaging Services**.

#### Option A: Use an Existing Messaging Service

1. In the current Twilio Console, open **Communications → Messaging → Services**. In the legacy Console, open **Messaging → Services**.
2. Select the service AirMDR should use.
3. Open **Properties**.
4. Copy the **Messaging Service SID**, which begins with `MG`.
5. Open **Sender Pool** \*\*→ Add Senders \*\*and verify that the service contains a suitable sender.
   1. Add a phone number,
   2. Short code, or supported alphanumeric sender ID that can reach your intended recipients.
      > [!NOTE]
      >
      > When sending to US recipients from a US 10DLC number, ensure that the number belongs to the selected Messaging Service and is associated with an approved A2P 10DLC campaign.

#### Option B: Create a Messaging Service

If an appropriate service does not exist:

1. Open **Communications → Messaging → Services**, or **Messaging → Services** in the legacy Console.
2. Click **Create a Messaging Service**.
3. Enter a descriptive name, such as `AirMDR Security Notifications`.
4. Select the messaging use case appropriate for your notifications.
5. Continue through the setup wizard.
6. Add an eligible sender to the **Sender Pool**.
7. Complete any applicable sender registration or verification requirements.
8. Open the created service and copy its **Messaging Service SID**.

> [!WARNING]
>
> The service must belong to the Account SID entered in AirMDR.
>
> Its Sender Pool must include at least one eligible phone number, short code, or supported alphanumeric sender.
>
> An empty Sender Pool prevents sending.

> [!NOTE]
>
> Twilio’s setup wizard guides you through sender configuration, application integration, and applicable compliance requirements.

### Twilio Credential Reference Table

| AirMDR Field | Value to Enter | Where to Obtain It |
| :- | :- | :- |
| **Account SID** | SID of the account that sends the messages; begins with `AC`. | Twilio Console home page → **Account Info**. |
| **Username** | Standard API Key SID beginning with `SK`, or the Account SID for account-based authentication. | API key creation result, or **Account Info**. |
| **Password** | Secret belonging to the API key, or the account Auth Token. | API key creation result, or the account’s Auth Token display. |
| **Messaging Service SID** | SID of the sending service; begins with `MG`. | **Messaging → Services** → select the service → **Properties**. |

> [!WARNING]
>
> Keep the credential pair together. An API Key SID must use its corresponding API Key Secret. An Account SID must use the corresponding account Auth Token.

## Configure Twilio in AirMDR Integrations Dashboard

1. Navigate to [AirMDR](https://app.airmdr.com/auth/login), provide the credentials and click **Login**
2. Navigate to the AirMDR Integrations Dashboard in the left navigation pane and select **ADMIN → Integrations**.
3. Use the search option, enter the keyword "**Twilio**", select the **Connections** tab, and click **+ New Connection** button.
4. Use the following values in the AirMDR integration configuration screen:

   | Field | Description | Example |
   | :- | :- | :- |
   | **Instance** | A unique name identifying this connection. | `Twilio-Production` |
   | **Organization** | The AirMDR organization that will use the connection. | Select the appropriate organization. |
   | **Description** | A short explanation of the connection’s purpose. | `SMS notifications for security responders.` |
   | **Account SID** | Twilio account that owns the Messaging Service. | `AC` followed by the account identifier. |
   | **Username** | Standard API Key SID, or Account SID when using account credentials. | `SK` followed by the key identifier. |
   | **Password** | Corresponding API Key Secret or Auth Token. | Enter the secret securely. |
   | **Messaging Service SID** | Twilio service used to send messages. | `MG` followed by the service identifier. |

   > **Expand Advanced Configuration if required. (Optional)**
   >
   > 1. In **Remote Agent**, select an AirMDR Remote Agent when Twilio requests must run through an approved network route. Ensure the selected agent can resolve and reach both `api.twilio.com` for sending messages and `messaging.twilio.com` for connection verification over HTTPS on TCP port `443`. For direct connectivity from AirMDR, leave this field unselected.
   >
   > 2. In **Expiry**, select a date according to your organization’s credential rotation policy, or an earlier date if the configured Twilio credentials will become invalid sooner.
   >
   > > [!NOTE]
   > >
   > > Expiry controls credential validity in AirMDR. It does not automatically rotate, extend, or revoke credentials in Twilio. For API key rotation, create a replacement key, update **Username** with its API Key SID, **Password** with its Secret, and **Expiry** with the revised date. Save and validate the connection, then delete the previous key when it is no longer required. If using an Account SID and Auth Token, coordinate token rotation with other applications that use the same token.
5. Click **Save**.

## Skills provided by this Integration & Permissions required

**Messaging — Outbound Actions**

| Operation | Identifier | Required access | Applicable role | Required permissions | Endpoint | Output |
| - | - | - | :- | :- | - | :- |
| Send Twilio Text Message | `send_twilio_text_message` | Create messages in the configured account. | **Developer** or **Administrator** for credential setup. Skill execution uses the credentials saved in the AirMDR connection. | Permission to create messages through `POST /2010-04-01/Accounts/{AccountSID}/Messages.json`. Authenticate using a **Standard API Key SID and Secret**, or the **Account SID and Auth Token**. | `POST https://api.twilio.com/2010-04-01/Accounts/{AccountSID}/Messages.json` | Twilio Message resource, including its `sid`and current `status`. |

> [!NOTE]
>
> An `accepted` or `queued` status confirms that Twilio accepted the request. It does not confirm delivery to the recipient.

> [!NOTE]
>
> Twilio Console roles govern user access during setup. Runtime access depends on the saved API credentials. A Standard API key provides broader account API access than message sending alone.

> [!TIP]
>
> To view the details of Input Parameters and Output for the respective skills
>
> * Go to [AirMDR → Twilio](https://app.airmdr.com/integrationsv2/56579f62-af8d-4572-9664-f8f7bb09dff1/skills?search=Twilio) Integration page.
> * Select the **Skills** tab and click on the required listed skills.

> **Skill Inputs**
>
> | Input | Required | Description |
> | :- | :- | :- |
> | `to_number` | Yes | Recipient phone number in E.164 format, such as `+14155550123`. Maps to Twilio’s `To` parameter. |
> | `body` | Yes | SMS message text. Maps to Twilio’s `Body` parameter and supports up to 1,600 characters. |
>
> The Account SID and Messaging Service SID come from the saved connection. Twilio selects the sender from the Messaging Service’s Sender Pool.
>
> **Request Behavior**
>
> Each skill execution makes one POST request. AirMDR does not automatically retry the send request.
>
> Requests use `application/x-www-form-urlencoded` encoding. A successful message creation returns **HTTP 201** and a Twilio Message resource.
>
> > [!TIP]
> >
> > If an execution times out, check Twilio’s logs before running it again. A manual rerun can create another message even though the integration itself does not automatically retry.

> **Send a Test SMS (Optional)**
>
> 1. Review the account, credential pair, and Messaging Service SID.
>
> 2. Click **Save**.
>
> 3. Open the **Skills** tab.
>
> 4. Locate **Send Twilio Text Message** and click **Run skill**.
>
> 5. Select the connection if prompted.
>
> 6. Enter the recipient phone number in international **E.164** format, such as `+14155550123`, and enter a short test message.
>
> 7. Run the skill once.
>
> 8. Record the returned Message SID and status.
>
> 9. Confirm the message’s final delivery status in Twilio.
>
> > [!NOTE]
> >
> > E.164 format uses `+`, the country code, and the subscriber number without spaces or punctuation.

> **Validate Connectivity**
>
> You can optionally validate the Twilio request.
>
> After saving the connection, run **Verify** in AirMDR.
>
> AirMDR retrieves the configured Messaging Service using: `GET https://messaging.twilio.com/v1/Services/{MessagingServiceSID}`
>
> It checks that the returned `account_SID` matches the **Account SID** saved in the connection.
>
> This verification reads the service configuration and does not send an SMS. Successful verification confirms access to the service and account ownership; it does not confirm delivery to a particular recipient.
>
> > [!NOTE]
> >
> > An optional test message can be sent separately using **Send Twilio Text Message**. This sends a real SMS and may incur charges.
>
> > **Sample Request (Send a Test SMS — Optional)**
> >
> > > [!NOTE]
> > >
> > > For API key authentication, `TWILIO_USERNAME` is the API Key SID and `TWILIO_PASSWORD` is its Secret. The Account SID remains a separate value in the URL. This request creates a real outbound SMS.
> >
> > ```text theme={null}
> > curl --request POST \
> >   "https://api.twilio.com/2010-04-01/Accounts/${TWILIO_ACCOUNT_SID}/Messages.json" \
> >   --user "${TWILIO_USERNAME}:${TWILIO_PASSWORD}" \
> >   --data-urlencode "MessagingServiceSid=${TWILIO_MESSAGING_SERVICE_SID}" \
> >   --data-urlencode "To=${TWILIO_RECIPIENT}" \
> >   --data-urlencode "Body=AirMDR integration validation message."
> > ```
>
> > **Sample Response**
> >
> > ```text theme={null}
> > {
> >   "sid": "SMXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
> >   "account_sid": "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
> >   "messaging_service_sid": "MGXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
> >   "to": "+14155550123",
> >   "from": null,
> >   "body": "AirMDR integration validation message.",
> >   "status": "accepted",
> >   "direction": "outbound-api",
> >   "num_segments": "0",
> >   "error_code": null,
> >   "error_message": null,
> >   "price": null,
> >   "price_unit": null
> > }
> > ```
> >
> > > [!NOTE]
> > >
> > > `accepted` confirms that Twilio received the request. Delivery and pricing information may become available later. Review the Message SID in Twilio’s Messaging Logs for the latest status.

## Additional Information

> **🧰 Error Handling**
>
> | Error or Symptom | Likely Cause | Recommended Action |
> | :- | :- | :- |
> | **20003 — Permission denied** | Incorrect, revoked, mismatched, or wrong-account credentials. | Verify the Account SID and credential pair. Check the key’s account and Region. Replace invalid credentials. |
> | **21211 — Invalid recipient number** | The recipient number is invalid or incorrectly formatted. | Use E.164 format and verify the country code and number. |
> | **21408 — Destination permissions disabled** | The destination is disabled in Geo Permissions or is unsupported. | Review **Messaging → Settings → Geo Permissions** and the destination’s messaging requirements. |
> | **21608 — Unverified recipient restriction** | Trial or account compliance restrictions prevent sending to the recipient. | Verify the test recipient or complete the account upgrade and compliance requirements identified by Twilio. |
> | **21704 — No available senders** | The Messaging Service has no eligible sender in its Sender Pool. | Add a suitable sender and confirm it can reach the destination. |
> | **21610 — Recipient unsubscribed** | The recipient opted out of messages. | Respect the opt-out. Resume messaging only through the applicable recipient consent and resubscription process. |
> | **20429 / HTTP 429 — Too many requests** | API concurrency limits were exceeded. | Reduce concurrent requests and retry rejected requests with exponential backoff. |
> | **Remote Agent connection failure** | The selected agent is unavailable or cannot reach Twilio. | Check agent availability, DNS resolution, proxy configuration, and outbound TCP `443` access. |
> | **Message accepted but not received** | Delivery is pending or failed after request acceptance. | Find the Message SID in Twilio’s Messaging Logs and review the latest status and error details. |
>
> > [!TIP]
> >
> > If a request times out without a clear result, check Twilio’s logs before resending. The original request may already have created a message, and repeating it may send a duplicate.

> **🔄 Monitoring & Logs**
>
> **Review Execution Results in AirMDR**
>
> 1. Open the result of the skill execution or the playbook step that ran it.
> 2. Review the returned Message SID and status.
> 3. Record any Twilio error code and error message.
> 4. Use the Message SID to correlate the execution with Twilio’s logs.
>
> **Review Messaging Logs in Twilio**
>
> 1. Sign in to the sending account in the Twilio Console.
> 2. Open **Monitor → Logs → Messaging**.
> 3. Search for the Message SID or filter by recipient and time.
> 4. Click the message’s linked date to open its details.
> 5. Review the delivery steps, status, sender, recipient, and errors. [Twilio](https://www.twilio.com/docs/messaging/features/messaging-logs?utm_source=chatgpt.com)
>
> **Interpret Message Status**
>
> | Status | Meaning |
> | :- | :- |
> | `accepted` | Twilio accepted the request through the Messaging Service. |
> | `queued` | The message is waiting to be sent. |
> | `sending` | Twilio is sending the message. |
> | `sent` | The upstream carrier accepted the message; recipient delivery is not yet confirmed. |
> | `delivered` | Twilio received delivery confirmation. |
> | `undelivered` | Twilio received a delivery-failure indication. |
> | `failed` | The message could not be sent. |
>
> Message status can change after the initial API response. [Twilio](https://www.twilio.com/docs/messaging/guides/track-outbound-message-status?utm_source=chatgpt.com)
>
> **Sample Monitoring Record**
>
> The following is an illustrative record for operational logging, rather than an exact AirMDR log format:
>
> ```text theme={null}
> {
>   "integration": "Twilio",
>   "skill": "Send Twilio Text Message",
>   "message_sid": "SMxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
>   "status": "accepted",
>   "recipient": "+********0123",
>   "delivery_confirmed": false
> }
> ```
>
> **Recommended Log Levels**
>
> Where your logging system supports configurable levels:
>
> | Level | Recommended Use |
> | :- | :- |
> | **INFO** | Execution outcome, Message SID, timestamp, and status. |
> | **WARNING** | Delivery delays or repeated transient failures. |
> | **ERROR** | Authentication failures, rejected requests, and failed delivery. |
> | **DEBUG** | Temporary troubleshooting with secrets and sensitive message content removed. |

> **🛑 Security & Access Best Practices**
>
> | **✅ Do** | **❌ Don’t** |
> | :- | :- |
> | Use a dedicated Twilio Standard API key for the AirMDR connection. | Don’t reuse one API key across unrelated applications or environments. |
> | Enter the API Key SID as **Username** and its Secret as **Password**. Alternatively, use the Account SID and its Auth Token. | Don’t mix credential pairs or enter your Twilio Console login credentials. |
> | Limit access to connection credentials and permission to run the messaging skill. | Don’t grant administrative access solely to send SMS notifications. |
> | Store secrets securely and redact them from troubleshooting evidence. | Don’t include API secrets, Auth Tokens, or Authorization headers in screenshots, logs, or support tickets. |
> | Allow HTTPS access to the required Twilio endpoint. | Don’t disable certificate validation to bypass connectivity errors. |
> | Enable only the destination countries required for your notifications. | Don’t enable unnecessary destinations in Messaging Geo Permissions. |
> | Send messages only to approved recipients and respect opt-out preferences. | Don’t repeatedly message recipients who have unsubscribed. |
> | Keep SMS content brief and link recipients to an authenticated system for sensitive details. | Don’t include passwords, access tokens, or confidential investigation details in SMS messages. |
> | Rotate credentials according to policy, update the AirMDR connection, and validate before retiring the previous credential. | Don’t assume the AirMDR **Expiry** field rotates or revokes credentials in Twilio. |
> | Review the Message SID and delivery status before retrying an uncertain execution. | Don’t automatically resend after a timeout; the original request may already have created a message. |
> | Monitor delivery failures, message volumes, and account usage. | Don’t treat `accepted`, `queued`, or `sent` as confirmation of recipient delivery. |
> | Coordinate account Auth Token rotation with every application using that token. | Don’t replace a shared Auth Token without assessing the impact on other integrations. |
>
> > [!NOTE]
> >
> > A Standard API key provides broad API access within its Twilio account. Selecting a Messaging Service in AirMDR does not restrict the key’s permissions to that service.

> **👉 Support & Maintenance**
>
> * 📧 Contact [**AirMDR Support**](mailto:support@airmdr.com) through your designated support channel.
> * 🔁 Rotate credentials regularly. Recommended cadence: As per your internal security policy.
> * Rotate API Credentials
>   1. Create a replacement Standard API key in the same Twilio account using **United States (US1)**.
>   2. Update the AirMDR connection’s **Username** and **Password**.
>   3. Save the connection.
>   4. Run one controlled validation.
>   5. Confirm that the new credential works.
>   6. Delete the previous API key in Twilio after confirming that it is no longer required.
>   > [!NOTE]
>   >
>   > Deleting an API key revokes its access.
> * Maintain the Integration
>   * Review the connection’s Expiry date and credential renewal schedule.
>   * Confirm that the Messaging Service retains an eligible sender.
>   * Review destination permissions, account balance, and sender registration status.
>   * Monitor failed messages, delivery delays, and unexpected usage.
>   * Revalidate the connection after changing credentials, the Messaging Service, or the Remote Agent.
>   * Review dependent playbooks before retiring a connection.
> * To revoke a dedicated API key, open **Settings → Account settings → API keys & auth tokens**, select the key, and click **Delete this key** after confirming that it is no longer required.

> **🛑 Data Flow & Security**
>
> **Data Exchanged**
>
> | Direction | Data |
> | :- | :- |
> | **AirMDR to Twilio — verification** | Authenticated request for the configured Messaging Service. |
> | **Twilio to AirMDR — verification** | Messaging Service details, including `account_sid`, used to validate account ownership. |
>
> The skill’s returned status reflects the message state at execution time. Use Twilio’s messaging logs to check subsequent delivery changes.
>
> **Encryption and Network Requirements**
>
> | Area | Requirement |
> | :- | :- |
> | **Message sending endpoint** | `api.twilio.com`, accessed over HTTPS on TCP port `443`. |
> | **Connection verification endpoint** | `messaging.twilio.com`, accessed over HTTPS on TCP port `443`. |
> | **Credential storage** | The API Key Secret or Auth Token entered in **Password** is stored encrypted in AirMDR. |
>
> The encrypted-password statement is supported by the SME’s credential table. Avoid adding an encryption algorithm or key-management claim because the PDF does not specify those details.

> **👉Message Limits and Queueing**
>
> | Item | Behavior |
> | - | - |
> | Maximum message body | Up to 1,600 characters. |
> | SMS segmentation | Messages exceeding 160 GSM-7 characters or 70 UCS-2 characters are split into segments and charged accordingly. |
> | Sending rate | Messages exceeding the applicable sending rate may wait in Twilio’s outgoing queue. |
> | `ValidityPeriod` | Twilio’s message queue validity parameter accepts 1–36,000 seconds, with a documented default of 36,000 seconds (10 hours). AirMDR does not send this parameter. |
> | Queue expiration | A message that remains queued beyond its applicable validity period is not sent. |
>
> > [!NOTE]
> >
> > Twilio’s message `ValidityPeriod` is separate from the **Expiry** field on the AirMDR connection. Connection Expiry does not set the SMS queue lifetime.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.