---
"@context": https://schema.org
"@type": TechArticle
"@id": https://www.twilio.com/docs/whatsapp/isv/register-senders#article
headline: Register WhatsApp senders - ISVs
description: Learn how Independent Software Vendors (ISVs) can register WhatsApp senders using Meta's Embedded Signup or the Senders API.
url: https://www.twilio.com/docs/whatsapp/isv/register-senders
inLanguage: en
dateModified: 2026-10-21T00:14:00.000Z
author:
  "@type": Organization
  name: Twilio Developer Education Team
publisher:
  "@type": Organization
  name: Twilio
---

# Register WhatsApp senders - ISVs

Learn how Independent Software Vendors (ISVs) can register WhatsApp senders for their customers using Meta's Embedded Signup or the Senders API.

## Phone number requirements

You can use either a Twilio phone number or a non-Twilio phone number to register a WhatsApp sender.

* The phone number must meet the [WhatsApp compatibility requirements](https://help.twilio.com/articles/360026678054).
* The phone number must not already be registered with WhatsApp. Learn how to [check if a phone number is registered with WhatsApp](#i-want-to-check-if-a-phone-number-is-registered-with-whatsapp) and how to [use an already registered phone number](#i-want-to-use-an-already-registered-phone-number).
* If the phone number is non-Twilio, it must be able to receive SMS or voice calls.
  * If the phone number is registered with an Interactive Voice Response (IVR) system or a computer-operated phone system, you can't receive One-Time Passwords (OTPs).
  * If the phone number is only available for outbound messages or calls, you can't use it to register a WhatsApp sender because Meta can't deliver OTPs.

## Display name requirements

The WhatsApp sender display name (`profile.name`) must comply with [Meta's display name guidelines](https://www.facebook.com/business/help/757569725593362). Meta reviews the name after registration. Before bulk registration, register a single sender first to confirm that the name is accepted. If Meta rejects the name, the phone number is limited to 250 business-initiated messages per 24-hour period, and Meta might disconnect the sender.

## Register the first WhatsApp sender

Your customer must register their first WhatsApp sender using Meta's Embedded Signup. The process involves the following steps:

1. You join the [Tech Provider Program](/docs/whatsapp/isv/tech-provider-program) and [integrate Meta's Embedded Signup](/docs/whatsapp/isv/tech-provider-program/integration-guide#part-3-complete-the-technical-integration) into your application.
2. Your customer registers the first WhatsApp sender using the Embedded Signup.\
   As part of the registration process, your customer will create a WhatsApp Business Account (WABA).
3. You [create a Twilio subaccount for your customer](/docs/whatsapp/isv/tech-provider-program/integration-guide#create-a-subaccount-for-each-customer), then [use the Senders API to connect their WABA to the subaccount](/docs/whatsapp/isv/tech-provider-program/integration-guide#register-the-whatsapp-sender).

## Register additional WhatsApp senders

After registering the first WhatsApp sender, there are two ways to register additional WhatsApp senders:

* **Embedded Signup**: Your customers register additional senders using the Embedded Signup in your application. If you have access to your customer's WABA, you can register WhatsApp senders on their behalf.
* **Senders API**: You register additional WhatsApp senders on behalf of your customers using the Senders API.

> \[!NOTE]
>
> Twilio recommends using the API only when you need to onboard a large number of senders across many accounts (bulk registration). Use the Embedded Signup for a small number of senders.

### Using the Embedded Signup in your application

You or your customers can register additional WhatsApp senders using the Embedded Signup flow they used to register their first WhatsApp sender.

> \[!WARNING]
>
> The Embedded Signup flow times out after 60 minutes of inactivity. Progress isn't saved and you must restart the registration process.

1. Click the **Login with Facebook** button in your application's UI.
2. Log in to Meta Business Manager.
3. Review the permissions Meta requests for your WABA and business assets, then continue.
4. Choose your Meta Business Portfolio and WABA.
   For each sender, you must select the same Meta Business Portfolio and WABA that you used for the first WhatsApp sender. Selecting a different Meta Business Portfolio or WABA will result in an error.
   > \[!NOTE]
   >
   > To select your WhatsApp Business Account, search by WABA ID or WABA account name or a connected number in your WABA. Please note, you can't use multiple WABAs in one Twilio account.
5. Enter the phone number you want to register and complete the OTP verification via SMS or voice call.
6. Review and accept the access/permissions required by the embedded flow.
7. Complete the flow and close the window once Meta confirms successful sender registration.
8. [Use the Senders API to connect the WABA to the Twilio subaccount](/docs/whatsapp/isv/tech-provider-program/integration-guide#register-the-whatsapp-sender).

### Using the Senders API

The [Senders API](/docs/whatsapp/api/senders) allows you to register additional WhatsApp senders on behalf of your customers. This is useful when you have many customers and each customer needs multiple senders created across many Twilio subaccounts.

Meta requires ownership verification for every phone number registered with WhatsApp before that number can send or receive messages. Meta verifies ownership through SMS or voice call OTPs.

The registration process depends on the phone number type (Twilio or non-Twilio) and capabilities (SMS or voice) to receive the OTP for verification.

| Phone number type | Capabilities | Verification | OTP verification code delivery                                                                                                                   |
| ----------------- | ------------ | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| Twilio            | SMS          | Automatic    | Twilio handles the verification automatically during the registration process.                                                                   |
|                   | Voice        | Manual       | Configure the phone number to receive the OTP verification code via email. You must manually complete the verification by making an API request. |
| Non-Twilio        | SMS          | Manual       | Receive the OTP verification code via SMS. You must manually complete the verification by making an API request.                                 |
|                   | Voice        | Manual       | Receive the OTP verification code via voice call. You must manually complete the verification by making an API request.                          |

## SMS: Twilio phone numbers

1. Buy a Twilio phone number that has SMS capabilities.

   Purchase a phone number

   ```js
   // Download the helper library from https://www.twilio.com/docs/node/install
   const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   const accountSid = process.env.TWILIO_ACCOUNT_SID;
   const apiKey = process.env.TWILIO_API_KEY;
   const apiSecret = process.env.TWILIO_API_SECRET;
   const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

   async function createIncomingPhoneNumber() {
     const incomingPhoneNumber = await client.incomingPhoneNumbers.create({
       phoneNumber: "+14155552344",
     });

     console.log(incomingPhoneNumber.accountSid);
   }

   createIncomingPhoneNumber();
   ```

   ```python
   # Download the helper library from https://www.twilio.com/docs/python/install
   import os
   from twilio.rest import Client

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = os.environ["TWILIO_API_KEY"]
   api_secret = os.environ["TWILIO_API_SECRET"]
   account_sid = os.environ["TWILIO_ACCOUNT_SID"]
   client = Client(api_key, api_secret, account_sid)

   incoming_phone_number = client.incoming_phone_numbers.create(
       phone_number="+14155552344"
   )

   print(incoming_phone_number.account_sid)
   ```

   ```csharp
   // Install the C# / .NET helper library from twilio.com/docs/csharp/install

   using System;
   using Twilio;
   using Twilio.Rest.Api.V2010.Account;
   using System.Threading.Tasks;

   class Program {
       public static async Task Main(string[] args) {
           // Find your Account SID at twilio.com/console
           // Provision API Keys at twilio.com/console/runtime/api-keys
           // and set the environment variables. See http://twil.io/secure
           // For local testing, you can use your Account SID and Auth token
           string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
           string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
           string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

           TwilioClient.Init(apiKey, apiSecret, accountSid);

           var incomingPhoneNumber = await IncomingPhoneNumberResource.CreateAsync(
               phoneNumber: new Twilio.Types.PhoneNumber("+14155552344"));

           Console.WriteLine(incomingPhoneNumber.AccountSid);
       }
   }
   ```

   ```java
   // Install the Java helper library from twilio.com/docs/java/install

   import com.twilio.type.PhoneNumber;
   import com.twilio.Twilio;
   import com.twilio.rest.api.v2010.account.IncomingPhoneNumber;

   public class Example {
       // Find your Account SID at twilio.com/console
       // Provision API Keys at twilio.com/console/runtime/api-keys
       // and set the environment variables. See http://twil.io/secure
       // For local testing, you can use your Account SID and Auth token
       public static final String API_KEY = System.getenv("TWILIO_API_KEY");
       public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
       public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

       public static void main(String[] args) {
           Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);
           IncomingPhoneNumber incomingPhoneNumber =
               IncomingPhoneNumber.creator(new com.twilio.type.PhoneNumber("+14155552344")).create();

           System.out.println(incomingPhoneNumber.getAccountSid());
       }
   }
   ```

   ```go
   // Download the helper library from https://www.twilio.com/docs/go/install
   package main

   import (
   	"fmt"
   	"github.com/twilio/twilio-go"
   	api "github.com/twilio/twilio-go/rest/api/v2010"
   	"os"
   )

   func main() {
   	// Find your Account SID at twilio.com/console
   	// Provision API Keys at twilio.com/console/runtime/api-keys
   	// and set the environment variables. See http://twil.io/secure
   	// For local testing, you can use your Account SID and Auth token
   	accountSid := os.Getenv("TWILIO_ACCOUNT_SID")
   	apiKey := os.Getenv("TWILIO_API_KEY")
   	apiSecret := os.Getenv("TWILIO_API_SECRET")
   	client := twilio.NewRestClientWithParams(twilio.ClientParams{
   		Username:   apiKey,
   		Password:   apiSecret,
   		AccountSid: accountSid,
   	})

   	params := &api.CreateIncomingPhoneNumberParams{}
   	params.SetPhoneNumber("+14155552344")

   	resp, err := client.Api.CreateIncomingPhoneNumber(params)
   	if err != nil {
   		fmt.Println(err.Error())
   		os.Exit(1)
   	} else {
   		if resp.AccountSid != nil {
   			fmt.Println(*resp.AccountSid)
   		} else {
   			fmt.Println(resp.AccountSid)
   		}
   	}
   }
   ```

   ```php
   <?php

   // Update the path below to your autoload.php,
   // see https://getcomposer.org/doc/01-basic-usage.md
   require_once "/path/to/vendor/autoload.php";

   use Twilio\Rest\Client;

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   $apiKey = $_ENV["TWILIO_API_KEY"];
   $apiSecret = $_ENV["TWILIO_API_SECRET"];
   $sid = $_ENV["TWILIO_ACCOUNT_SID"];
   $twilio = new Client($apiKey, $apiSecret, $sid);

   $incoming_phone_number = $twilio->incomingPhoneNumbers->create([
       "phoneNumber" => "+14155552344",
   ]);

   print $incoming_phone_number->accountSid;
   ```

   ```ruby
   # Download the helper library from https://www.twilio.com/docs/ruby/install
   require 'twilio-ruby'

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = ENV['TWILIO_API_KEY']
   api_secret = ENV['TWILIO_API_SECRET']
   account_sid = ENV['TWILIO_ACCOUNT_SID']
   @client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

   incoming_phone_number = @client
                           .api
                           .v2010
                           .incoming_phone_numbers
                           .create(phone_number: '+14155552344')

   puts incoming_phone_number.account_sid
   ```

   ```bash
   # Install the twilio-cli from https://twil.io/cli

   twilio api:core:incoming-phone-numbers:create \
      --phone-number +14155552344
   ```

   ```bash
   curl -X POST "https://api.twilio.com/2010-04-01/Accounts/$TWILIO_ACCOUNT_SID/IncomingPhoneNumbers.json" \
   --data-urlencode "PhoneNumber=+14155552344" \
   -u $TWILIO_API_KEY:$TWILIO_API_SECRET
   ```

   * The phone number must belong to the Twilio account or subaccount where you want to register the WhatsApp sender.
   * You can find available Twilio phone numbers by using the [AvailablePhoneNumbers Local](/docs/phone-numbers/api/availablephonenumberlocal-resource), [AvailablePhoneNumbers Mobile](/docs/phone-numbers/api/availablephonenumber-mobile-resource), and [AvailablePhoneNumbers TollFree](/docs/phone-numbers/api/availablephonenumber-tollfree-resource) resources.
   * Alternatively, you can [buy a Twilio phone number in the Twilio Console](https://console.twilio.com/us1/develop/phone-numbers/manage/search).
2. To register a WhatsApp sender, make a `POST /v2/Channels/Senders` request. The following properties are required in the request body:

   * `sender_id`: The phone number to register as a WhatsApp sender in [E.164 format](/docs/glossary/what-e164)
   * `profile.name`: The [WhatsApp sender display name](#display-name-requirements)

   For additional properties, see the [Senders API documentation](/docs/whatsapp/api/senders).

   > \[!WARNING]
   >
   > Allow several minutes between Senders API requests. Too many requests in a short period might result in errors.

   Register a WhatsApp sender (SMS: Twilio phone numbers)

   ```js
   // Download the helper library from https://www.twilio.com/docs/node/install
   const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   const accountSid = process.env.TWILIO_ACCOUNT_SID;
   const apiKey = process.env.TWILIO_API_KEY;
   const apiSecret = process.env.TWILIO_API_SECRET;
   const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

   async function createChannelsSender() {
     const channelsSender = await client.messaging.v2.channelsSenders.create({
       sender_id: "whatsapp:+15017122661",
       webhook: {
         callback_url: "https://demo.twilio.com/welcome/sms/reply/",
         callback_method: "POST",
       },
       profile: {
         name: "Twilio",
         about: "Hello! We are Twilio.",
         address: "101 Spear Street, San Francisco, CA",
         description: "We're excited to see what you build!",
         logo_url: "https://www.twilio.com/logo.png",
         vertical: "Other",
         websites: ["https://twilio.com", "https://help.twilio.com"],
         emails: ["support@twilio.com"],
       },
     });

     console.log(channelsSender.sid);
   }

   createChannelsSender();
   ```

   ```python
   # Download the helper library from https://www.twilio.com/docs/python/install
   import os
   from twilio.rest import Client
   from twilio.rest.messaging.v2 import ChannelsSenderList

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = os.environ["TWILIO_API_KEY"]
   api_secret = os.environ["TWILIO_API_SECRET"]
   account_sid = os.environ["TWILIO_ACCOUNT_SID"]
   client = Client(api_key, api_secret, account_sid)

   channels_sender = client.messaging.v2.channels_senders.create(
       messaging_v2_channels_sender_requests_create=ChannelsSenderList.MessagingV2ChannelsSenderRequestsCreate(
           {
               "sender_id": "whatsapp:+15017122661",
               "webhook": ChannelsSenderList.MessagingV2ChannelsSenderWebhook(
                   {
                       "callback_url": "https://demo.twilio.com/welcome/sms/reply/",
                       "callback_method": "POST",
                   }
               ),
               "profile": ChannelsSenderList.MessagingV2ChannelsSenderProfile(
                   {
                       "name": "Twilio",
                       "about": "Hello! We are Twilio.",
                       "address": "101 Spear Street, San Francisco, CA",
                       "description": "We're excited to see what you build!",
                       "logo_url": "https://www.twilio.com/logo.png",
                       "vertical": "Other",
                       "websites": [
                           "https://twilio.com",
                           "https://help.twilio.com",
                       ],
                       "emails": ["support@twilio.com"],
                   }
               ),
           }
       )
   )

   print(channels_sender.sid)
   ```

   ```csharp
   // Install the C# / .NET helper library from twilio.com/docs/csharp/install

   using System;
   using Twilio;
   using Twilio.Rest.Messaging.V2;
   using System.Threading.Tasks;
   using System.Collections.Generic;

   class Program {
       public static async Task Main(string[] args) {
           // Find your Account SID at twilio.com/console
           // Provision API Keys at twilio.com/console/runtime/api-keys
           // and set the environment variables. See http://twil.io/secure
           // For local testing, you can use your Account SID and Auth token
           string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
           string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
           string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

           TwilioClient.Init(apiKey, apiSecret, accountSid);

           var channelsSender = await ChannelsSenderResource.CreateAsync(
               messagingV2ChannelsSenderRequestsCreate: new ChannelsSenderResource
                   .MessagingV2ChannelsSenderRequestsCreate.Builder()
                   .WithSenderId("whatsapp:+15017122661")
                   .WithWebhook(new ChannelsSenderResource.MessagingV2ChannelsSenderWebhook.Builder()
                                    .WithCallbackUrl("https://demo.twilio.com/welcome/sms/reply/")
                                    .WithCallbackMethod("POST")
                                    .Build())
                   .WithProfile(
                       new ChannelsSenderResource.MessagingV2ChannelsSenderProfile.Builder()
                           .WithName("Twilio")
                           .WithAbout("Hello! We are Twilio.")
                           .WithAddress("101 Spear Street, San Francisco, CA")
                           .WithDescription("We're excited to see what you build!")
                           .WithLogoUrl("https://www.twilio.com/logo.png")
                           .WithVertical("Other")
                           .WithWebsites(
                               new List<string> { "https://twilio.com", "https://help.twilio.com" })
                           .WithEmails(new List<string> { "support@twilio.com" })
                           .Build())
                   .Build());

           Console.WriteLine(channelsSender.Sid);
       }
   }
   ```

   ```java
   // Install the Java helper library from twilio.com/docs/java/install

   import java.util.Arrays;
   import java.util.HashMap;
   import com.twilio.Twilio;
   import com.twilio.rest.messaging.v2.ChannelsSender;

   public class Example {
       // Find your Account SID at twilio.com/console
       // Provision API Keys at twilio.com/console/runtime/api-keys
       // and set the environment variables. See http://twil.io/secure
       // For local testing, you can use your Account SID and Auth token
       public static final String API_KEY = System.getenv("TWILIO_API_KEY");
       public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
       public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

       public static void main(String[] args) {
           Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);

           ChannelsSender.MessagingV2ChannelsSenderWebhook webhook = new ChannelsSender.MessagingV2ChannelsSenderWebhook();
           webhook.setCallbackUrl("https://demo.twilio.com/welcome/sms/reply/");
           webhook.setCallbackMethod("POST");

           ChannelsSender.MessagingV2ChannelsSenderProfile profile = new ChannelsSender.MessagingV2ChannelsSenderProfile();
           profile.setName("Twilio");
           profile.setAbout("Hello! We are Twilio.");
           profile.setAddress("101 Spear Street, San Francisco, CA");
           profile.setDescription("We're excited to see what you build!");
           profile.setLogoUrl("https://www.twilio.com/logo.png");
           profile.setVertical("Other");
           profile.setWebsites(Arrays.asList("https://twilio.com", "https://help.twilio.com"));
           profile.setEmails(Arrays.asList("support@twilio.com"));

           ChannelsSender.MessagingV2ChannelsSenderRequestsCreate messagingV2ChannelsSenderRequestsCreate =
               new ChannelsSender.MessagingV2ChannelsSenderRequestsCreate();
           messagingV2ChannelsSenderRequestsCreate.setSenderId("whatsapp:+15017122661");
           messagingV2ChannelsSenderRequestsCreate.setWebhook(messagingV2ChannelsSenderWebhook);
           messagingV2ChannelsSenderRequestsCreate.setProfile(messagingV2ChannelsSenderProfile);

           ChannelsSender channelsSender = ChannelsSender.creator(messagingV2ChannelsSenderRequestsCreate).create();

           System.out.println(channelsSender.getSid());
       }
   }
   ```

   ```go
   // Download the helper library from https://www.twilio.com/docs/go/install
   package main

   import (
   	"fmt"
   	"github.com/twilio/twilio-go"
   	messaging "github.com/twilio/twilio-go/rest/messaging/v2"
   	"os"
   )

   func ptrOf[T any](v T) *T { return &v }

   func main() {
   	// Find your Account SID at twilio.com/console
   	// Provision API Keys at twilio.com/console/runtime/api-keys
   	// and set the environment variables. See http://twil.io/secure
   	// For local testing, you can use your Account SID and Auth token
   	accountSid := os.Getenv("TWILIO_ACCOUNT_SID")
   	apiKey := os.Getenv("TWILIO_API_KEY")
   	apiSecret := os.Getenv("TWILIO_API_SECRET")
   	client := twilio.NewRestClientWithParams(twilio.ClientParams{
   		Username:   apiKey,
   		Password:   apiSecret,
   		AccountSid: accountSid,
   	})

   	params := &messaging.CreateChannelsSenderParams{}
   	params.SetMessagingV2ChannelsSenderRequestsCreate(messaging.MessagingV2ChannelsSenderRequestsCreate{
   		SenderId: ptrOf("whatsapp:+15017122661"),
   		Webhook: &messaging.MessagingV2ChannelsSenderWebhook{
   			CallbackUrl:    ptrOf("https://demo.twilio.com/welcome/sms/reply/"),
   			CallbackMethod: ptrOf("POST"),
   		},
   		Profile: &messaging.MessagingV2ChannelsSenderProfile{
   			Name:        ptrOf("Twilio"),
   			About:       ptrOf("Hello! We are Twilio."),
   			Address:     ptrOf("101 Spear Street, San Francisco, CA"),
   			Description: ptrOf("We're excited to see what you build!"),
   			LogoUrl:     ptrOf("https://www.twilio.com/logo.png"),
   			Vertical:    ptrOf("Other"),
   			Websites: []string{
   				"https://twilio.com",
   				"https://help.twilio.com",
   			},
   			Emails: []string{
   				"support@twilio.com",
   			},
   		},
   	})

   	resp, err := client.MessagingV2.CreateChannelsSender(params)
   	if err != nil {
   		fmt.Println(err.Error())
   		os.Exit(1)
   	} else {
   		if resp.Sid != nil {
   			fmt.Println(*resp.Sid)
   		} else {
   			fmt.Println(resp.Sid)
   		}
   	}
   }
   ```

   ```php
   <?php

   // Update the path below to your autoload.php,
   // see https://getcomposer.org/doc/01-basic-usage.md
   require_once "/path/to/vendor/autoload.php";

   use Twilio\Rest\Client;
   use Twilio\Rest\Messaging\V2\ChannelsSenderModels;

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   $apiKey = $_ENV["TWILIO_API_KEY"];
   $apiSecret = $_ENV["TWILIO_API_SECRET"];
   $sid = $_ENV["TWILIO_ACCOUNT_SID"];
   $twilio = new Client($apiKey, $apiSecret, $sid);

   $channels_sender = $twilio->messaging->v2->channelsSenders->create(
       ChannelsSenderModels::createMessagingV2ChannelsSenderRequestsCreate([
           "senderId" => "whatsapp:+15017122661",
           "webhook" => ChannelsSenderModels::createMessagingV2ChannelsSenderWebhook(
               [
                   "callbackUrl" => "https://demo.twilio.com/welcome/sms/reply/",
                   "callbackMethod" => "POST",
               ],
           ),
           "profile" => ChannelsSenderModels::createMessagingV2ChannelsSenderProfile(
               [
                   "name" => "Twilio",
                   "about" => "Hello! We are Twilio.",
                   "address" => "101 Spear Street, San Francisco, CA",
                   "description" => "We're excited to see what you build!",
                   "logoUrl" => "https://www.twilio.com/logo.png",
                   "vertical" => "Other",
                   "websites" => ["https://twilio.com", "https://help.twilio.com"],
                   "emails" => ["support@twilio.com"],
               ],
           ),
       ]),
   );

   print $channels_sender->sid;
   ```

   ```ruby
   # Download the helper library from https://www.twilio.com/docs/ruby/install
   require 'twilio-ruby'

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = ENV['TWILIO_API_KEY']
   api_secret = ENV['TWILIO_API_SECRET']
   account_sid = ENV['TWILIO_ACCOUNT_SID']
   @client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

   channels_sender = @client
                     .messaging
                     .v2
                     .channels_senders
                     .create(
                       messaging_v2_channels_sender_requests_create: {
                         'sender_id' => 'whatsapp:+15017122661',
                         'webhook' => {
                           'callback_url' => 'https://demo.twilio.com/welcome/sms/reply/',
                           'callback_method' => 'POST'
                         },
                         'profile' => {
                           'name' => 'Twilio',
                           'about' => 'Hello! We are Twilio.',
                           'address' => '101 Spear Street, San Francisco, CA',
                           'description' => 'We\'re excited to see what you build!',
                           'logo_url' => 'https://www.twilio.com/logo.png',
                           'vertical' => 'Other',
                           'websites' => [
                             'https://twilio.com',
                             'https://help.twilio.com'
                           ],
                           'emails' => [
                             'support@twilio.com'
                           ]
                         }
                       }
                     )

   puts channels_sender.sid
   ```

   ```bash
   # This endpoint is not currently supported by the Twilio CLI. You can open an issue to request it on https://github.com/twilio/twilio-cli/issues
     # For an alternative low-code solution, check out https://www.twilio.com/docs/openapi/using-twilio-postman-collections
   ```

   ```bash
   EXCLAMATION_MARK='!'

   MESSAGING_V2_CHANNELS_SENDER_REQUESTS_CREATE_OBJ=$(cat << EOF
   {
     "sender_id": "whatsapp:+15017122661",
     "webhook": {
       "callback_url": "https://demo.twilio.com/welcome/sms/reply/",
       "callback_method": "POST"
     },
     "profile": {
       "name": "Twilio",
       "about": "Hello$EXCLAMATION_MARK We are Twilio.",
       "address": "101 Spear Street, San Francisco, CA",
       "description": "We're excited to see what you build!",
       "logo_url": "https://www.twilio.com/logo.png",
       "vertical": "Other",
       "websites": [
         "https://twilio.com",
         "https://help.twilio.com"
       ],
       "emails": [
         "support@twilio.com"
       ]
     }
   }
   EOF
   )
   curl -X POST "https://messaging.twilio.com/v2/Channels/Senders" \
   --json "$MESSAGING_V2_CHANNELS_SENDER_REQUESTS_CREATE_OBJ" \
   -u $TWILIO_API_KEY:$TWILIO_API_SECRET
   ```

   ```json
   {
     "sid": "XEaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
     "status": "CREATING",
     "sender_id": "whatsapp:+15017122661",
     "configuration": {
       "waba_id": "1234567XXX",
       "verification_method": "sms",
       "verification_code": null,
       "voice_application_sid": "APXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
       "account_type": null
     },
     "webhook": {
       "callback_url": "https://demo.twilio.com/welcome/sms/reply/",
       "callback_method": "POST"
     },
     "profile": {
       "name": "Twilio",
       "about": "Hello! We are Twilio.",
       "address": "101 Spear Street, San Francisco, CA",
       "description": "We're excited to see what you build!",
       "logo_url": "https://www.twilio.com/logo.png",
       "vertical": "Other",
       "websites": [
         "https://twilio.com",
         "https://help.twilio.com"
       ],
       "emails": [
         "support@twilio.com"
       ]
     }
   }
   ```

   This request creates a WhatsApp sender in Twilio's system, adds it to the WABA connected to your Twilio account, and completes the phone number verification.
3. To confirm that the WhatsApp sender is registered, make a `GET v2/Channels/Senders/{Sid}` request and check if `status` is `ONLINE`.\
   **Note**: Immediately after registration, the `status` value will be `OFFLINE`. Wait a few minutes, then make the request again.

   Confirm WhatsApp sender registration

   ```js
   // Download the helper library from https://www.twilio.com/docs/node/install
   const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   const accountSid = process.env.TWILIO_ACCOUNT_SID;
   const apiKey = process.env.TWILIO_API_KEY;
   const apiSecret = process.env.TWILIO_API_SECRET;
   const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

   async function fetchChannelsSender() {
     const channelsSender = await client.messaging.v2
       .channelsSenders("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
       .fetch();

     console.log(channelsSender.sid);
   }

   fetchChannelsSender();
   ```

   ```python
   # Download the helper library from https://www.twilio.com/docs/python/install
   import os
   from twilio.rest import Client

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = os.environ["TWILIO_API_KEY"]
   api_secret = os.environ["TWILIO_API_SECRET"]
   account_sid = os.environ["TWILIO_ACCOUNT_SID"]
   client = Client(api_key, api_secret, account_sid)

   channels_sender = client.messaging.v2.channels_senders(
       "XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
   ).fetch()

   print(channels_sender.sid)
   ```

   ```csharp
   // Install the C# / .NET helper library from twilio.com/docs/csharp/install

   using System;
   using Twilio;
   using Twilio.Rest.Messaging.V2;
   using System.Threading.Tasks;

   class Program {
       public static async Task Main(string[] args) {
           // Find your Account SID at twilio.com/console
           // Provision API Keys at twilio.com/console/runtime/api-keys
           // and set the environment variables. See http://twil.io/secure
           // For local testing, you can use your Account SID and Auth token
           string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
           string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
           string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

           TwilioClient.Init(apiKey, apiSecret, accountSid);

           var channelsSender =
               await ChannelsSenderResource.FetchAsync(pathSid: "XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");

           Console.WriteLine(channelsSender.Sid);
       }
   }
   ```

   ```java
   // Install the Java helper library from twilio.com/docs/java/install

   import com.twilio.Twilio;
   import com.twilio.rest.messaging.v2.ChannelsSender;

   public class Example {
       // Find your Account SID at twilio.com/console
       // Provision API Keys at twilio.com/console/runtime/api-keys
       // and set the environment variables. See http://twil.io/secure
       // For local testing, you can use your Account SID and Auth token
       public static final String API_KEY = System.getenv("TWILIO_API_KEY");
       public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
       public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

       public static void main(String[] args) {
           Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);
           ChannelsSender channelsSender = ChannelsSender.fetcher("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX").fetch();

           System.out.println(channelsSender.getSid());
       }
   }
   ```

   ```go
   // Download the helper library from https://www.twilio.com/docs/go/install
   package main

   import (
   	"fmt"
   	"github.com/twilio/twilio-go"
   	"os"
   )

   func main() {
   	// Find your Account SID at twilio.com/console
   	// Provision API Keys at twilio.com/console/runtime/api-keys
   	// and set the environment variables. See http://twil.io/secure
   	// For local testing, you can use your Account SID and Auth token
   	accountSid := os.Getenv("TWILIO_ACCOUNT_SID")
   	apiKey := os.Getenv("TWILIO_API_KEY")
   	apiSecret := os.Getenv("TWILIO_API_SECRET")
   	client := twilio.NewRestClientWithParams(twilio.ClientParams{
   		Username:   apiKey,
   		Password:   apiSecret,
   		AccountSid: accountSid,
   	})

   	resp, err := client.MessagingV2.FetchChannelsSender("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
   	if err != nil {
   		fmt.Println(err.Error())
   		os.Exit(1)
   	} else {
   		if resp.Sid != nil {
   			fmt.Println(*resp.Sid)
   		} else {
   			fmt.Println(resp.Sid)
   		}
   	}
   }
   ```

   ```php
   <?php

   // Update the path below to your autoload.php,
   // see https://getcomposer.org/doc/01-basic-usage.md
   require_once "/path/to/vendor/autoload.php";

   use Twilio\Rest\Client;

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   $apiKey = $_ENV["TWILIO_API_KEY"];
   $apiSecret = $_ENV["TWILIO_API_SECRET"];
   $sid = $_ENV["TWILIO_ACCOUNT_SID"];
   $twilio = new Client($apiKey, $apiSecret, $sid);

   $channels_sender = $twilio->messaging->v2
       ->channelsSenders("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
       ->fetch();

   print $channels_sender->sid;
   ```

   ```ruby
   # Download the helper library from https://www.twilio.com/docs/ruby/install
   require 'twilio-ruby'

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = ENV['TWILIO_API_KEY']
   api_secret = ENV['TWILIO_API_SECRET']
   account_sid = ENV['TWILIO_ACCOUNT_SID']
   @client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

   channels_sender = @client
                     .messaging
                     .v2
                     .channels_senders('XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                     .fetch

   puts channels_sender.sid
   ```

   ```bash
   # Install the twilio-cli from https://twil.io/cli

   twilio api:messaging:v2:channels:senders:fetch \
      --sid XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   ```

   ```bash
   curl -X GET "https://messaging.twilio.com/v2/Channels/Senders/XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
   -u $TWILIO_API_KEY:$TWILIO_API_SECRET
   ```

   ```json
   {
     "sid": "XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
     "status": "ONLINE",
     "sender_id": "whatsapp:+999999999XX",
     "configuration": {
       "waba_id": "1234567XXX",
       "verification_method": null,
       "verification_code": null,
       "voice_application_sid": "APXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
       "account_type": null
     },
     "webhook": {
       "callback_url": "https://callback.example.com",
       "callback_method": "POST",
       "fallback_url": "https://fallback.example.com",
       "fallback_method": "POST",
       "status_callback_url": "https://statuscallback.example.com",
       "status_callback_method": "POST"
     },
     "profile": {
       "name": "Example Profile Name",
       "about": "This is an example about text.",
       "address": "123 Example St, Example City, EX 12345",
       "description": "This is an example description.",
       "emails": [
         {
           "email": "email@email.com",
           "label": "Email"
         }
       ],
       "logo_url": "https://logo_url.example.com",
       "vertical": "Automotive",
       "websites": [
         {
           "website": "https://website1.example.com",
           "label": "Website"
         },
         {
           "website": "http://website2.example.com",
           "label": "Website"
         }
       ],
       "banner_url": null,
       "privacy_url": null,
       "terms_of_service_url": null,
       "accent_color": null,
       "use_case": null,
       "phone_numbers": null
     },
     "compliance": null,
     "properties": {
       "quality_rating": "HIGH",
       "messaging_limit": "10K Customers/24hr"
     },
     "offline_reasons": null,
     "url": "https://messaging.twilio.com/v2/Channels/Senders/XEaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
   }
   ```

## Voice: Twilio phone numbers

1. Buy a Twilio phone number that has voice capabilities.

   Purchase a phone number

   ```js
   // Download the helper library from https://www.twilio.com/docs/node/install
   const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   const accountSid = process.env.TWILIO_ACCOUNT_SID;
   const apiKey = process.env.TWILIO_API_KEY;
   const apiSecret = process.env.TWILIO_API_SECRET;
   const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

   async function createIncomingPhoneNumber() {
     const incomingPhoneNumber = await client.incomingPhoneNumbers.create({
       phoneNumber: "+14155552344",
     });

     console.log(incomingPhoneNumber.accountSid);
   }

   createIncomingPhoneNumber();
   ```

   ```python
   # Download the helper library from https://www.twilio.com/docs/python/install
   import os
   from twilio.rest import Client

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = os.environ["TWILIO_API_KEY"]
   api_secret = os.environ["TWILIO_API_SECRET"]
   account_sid = os.environ["TWILIO_ACCOUNT_SID"]
   client = Client(api_key, api_secret, account_sid)

   incoming_phone_number = client.incoming_phone_numbers.create(
       phone_number="+14155552344"
   )

   print(incoming_phone_number.account_sid)
   ```

   ```csharp
   // Install the C# / .NET helper library from twilio.com/docs/csharp/install

   using System;
   using Twilio;
   using Twilio.Rest.Api.V2010.Account;
   using System.Threading.Tasks;

   class Program {
       public static async Task Main(string[] args) {
           // Find your Account SID at twilio.com/console
           // Provision API Keys at twilio.com/console/runtime/api-keys
           // and set the environment variables. See http://twil.io/secure
           // For local testing, you can use your Account SID and Auth token
           string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
           string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
           string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

           TwilioClient.Init(apiKey, apiSecret, accountSid);

           var incomingPhoneNumber = await IncomingPhoneNumberResource.CreateAsync(
               phoneNumber: new Twilio.Types.PhoneNumber("+14155552344"));

           Console.WriteLine(incomingPhoneNumber.AccountSid);
       }
   }
   ```

   ```java
   // Install the Java helper library from twilio.com/docs/java/install

   import com.twilio.type.PhoneNumber;
   import com.twilio.Twilio;
   import com.twilio.rest.api.v2010.account.IncomingPhoneNumber;

   public class Example {
       // Find your Account SID at twilio.com/console
       // Provision API Keys at twilio.com/console/runtime/api-keys
       // and set the environment variables. See http://twil.io/secure
       // For local testing, you can use your Account SID and Auth token
       public static final String API_KEY = System.getenv("TWILIO_API_KEY");
       public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
       public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

       public static void main(String[] args) {
           Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);
           IncomingPhoneNumber incomingPhoneNumber =
               IncomingPhoneNumber.creator(new com.twilio.type.PhoneNumber("+14155552344")).create();

           System.out.println(incomingPhoneNumber.getAccountSid());
       }
   }
   ```

   ```go
   // Download the helper library from https://www.twilio.com/docs/go/install
   package main

   import (
   	"fmt"
   	"github.com/twilio/twilio-go"
   	api "github.com/twilio/twilio-go/rest/api/v2010"
   	"os"
   )

   func main() {
   	// Find your Account SID at twilio.com/console
   	// Provision API Keys at twilio.com/console/runtime/api-keys
   	// and set the environment variables. See http://twil.io/secure
   	// For local testing, you can use your Account SID and Auth token
   	accountSid := os.Getenv("TWILIO_ACCOUNT_SID")
   	apiKey := os.Getenv("TWILIO_API_KEY")
   	apiSecret := os.Getenv("TWILIO_API_SECRET")
   	client := twilio.NewRestClientWithParams(twilio.ClientParams{
   		Username:   apiKey,
   		Password:   apiSecret,
   		AccountSid: accountSid,
   	})

   	params := &api.CreateIncomingPhoneNumberParams{}
   	params.SetPhoneNumber("+14155552344")

   	resp, err := client.Api.CreateIncomingPhoneNumber(params)
   	if err != nil {
   		fmt.Println(err.Error())
   		os.Exit(1)
   	} else {
   		if resp.AccountSid != nil {
   			fmt.Println(*resp.AccountSid)
   		} else {
   			fmt.Println(resp.AccountSid)
   		}
   	}
   }
   ```

   ```php
   <?php

   // Update the path below to your autoload.php,
   // see https://getcomposer.org/doc/01-basic-usage.md
   require_once "/path/to/vendor/autoload.php";

   use Twilio\Rest\Client;

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   $apiKey = $_ENV["TWILIO_API_KEY"];
   $apiSecret = $_ENV["TWILIO_API_SECRET"];
   $sid = $_ENV["TWILIO_ACCOUNT_SID"];
   $twilio = new Client($apiKey, $apiSecret, $sid);

   $incoming_phone_number = $twilio->incomingPhoneNumbers->create([
       "phoneNumber" => "+14155552344",
   ]);

   print $incoming_phone_number->accountSid;
   ```

   ```ruby
   # Download the helper library from https://www.twilio.com/docs/ruby/install
   require 'twilio-ruby'

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = ENV['TWILIO_API_KEY']
   api_secret = ENV['TWILIO_API_SECRET']
   account_sid = ENV['TWILIO_ACCOUNT_SID']
   @client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

   incoming_phone_number = @client
                           .api
                           .v2010
                           .incoming_phone_numbers
                           .create(phone_number: '+14155552344')

   puts incoming_phone_number.account_sid
   ```

   ```bash
   # Install the twilio-cli from https://twil.io/cli

   twilio api:core:incoming-phone-numbers:create \
      --phone-number +14155552344
   ```

   ```bash
   curl -X POST "https://api.twilio.com/2010-04-01/Accounts/$TWILIO_ACCOUNT_SID/IncomingPhoneNumbers.json" \
   --data-urlencode "PhoneNumber=+14155552344" \
   -u $TWILIO_API_KEY:$TWILIO_API_SECRET
   ```

   * You can find available Twilio phone numbers by using the [AvailablePhoneNumbers Local](/docs/phone-numbers/api/availablephonenumberlocal-resource), [AvailablePhoneNumbers Mobile](/docs/phone-numbers/api/availablephonenumber-mobile-resource), and [AvailablePhoneNumbers TollFree](/docs/phone-numbers/api/availablephonenumber-tollfree-resource) resources.
   * Alternatively, you can [buy a Twilio phone number in the Twilio Console](https://console.twilio.com/us1/develop/phone-numbers/manage/search).
2. Configure the phone number so it can receive OTP verification codes via voice call.

<TabGroup>
  <Tab title="New Twilio console">
    1) Go to [Numbers & senders](https://1console.twilio.com/go?to=/account/__account__/us1/senders-hub/list/phone-numbers/inventory) and select the number you'd like to connect to the Flow. If you don't have any phone numbers, click **Set up a new phone number**.
    2) Select the *Configuration details* tab.
    3) Select **Messaging**, then click **Edit details**.
    4) On the *Edit messaging configuration* dialog, select the **Webhook, TwiML Bin, Function, Studio Flow, Proxy Service** option.
    5) Under *How do you want to set up your primary method?*, select **Webhook**.
    6) Paste the following webhook into the page, replacing `<YOUR_EMAIL_ADDRESS>` with your email address: `https://twimlets.com/voicemail?Email=<YOUR_EMAIL_ADDRESS>`.
       For example, `https://twimlets.com/voicemail?Email=support@example.com`. The [Voicemail Twimlet](https://console.twilio.com/us1/develop/twimlets/create?twimlet=voicemail) transcribes incoming calls and sends the transcription to your email address. This allows you to receive OTPs via email.
  </Tab>

  <Tab title="Legacy console">
    1. Open the [Active Numbers page (legacy console)](https://www.twilio.com/console/phone-numbers/incoming).
    2. Click your Twilio phone number.
    3. In the **Voice Configuration** section, in the **Configure with** row, select **Webhook, TwiML Bin, Function, Studio Flow, Proxy Service**.
    4. In the **A call comes in** row, select **Webhook** and set the **URL** to `https://twimlets.com/voicemail?Email=<YOUR_EMAIL_ADDRESS>`. For example, `https://twimlets.com/voicemail?Email=support@example.com`.\
       **Note**: The [Voicemail Twimlet](https://console.twilio.com/us1/develop/twimlets/create?twimlet=voicemail) transcribes incoming calls and sends the transcription to your email address. This allows you to receive OTPs via email.
  </Tab>
</TabGroup>

3. To register a WhatsApp sender, make a `POST /v2/Channels/Senders` request. The following properties are required in the request body:

   * `sender_id`: The phone number to register as a WhatsApp sender in [E.164 format](/docs/glossary/what-e164)
   * `profile.name`: The [WhatsApp sender display name](#display-name-requirements)

   For additional properties, see the [Senders API documentation](/docs/whatsapp/api/senders).

   > \[!WARNING]
   >
   > Allow several minutes between Senders API requests. Too many requests in a short period might result in errors.

   Register a WhatsApp sender (Voice: Twilio phone numbers)

   ```js
   // Download the helper library from https://www.twilio.com/docs/node/install
   const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   const accountSid = process.env.TWILIO_ACCOUNT_SID;
   const apiKey = process.env.TWILIO_API_KEY;
   const apiSecret = process.env.TWILIO_API_SECRET;
   const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

   async function createChannelsSender() {
     const channelsSender = await client.messaging.v2.channelsSenders.create({
       sender_id: "whatsapp:+15017122661",
       configuration: {
         verification_method: "voice",
       },
       webhook: {
         callback_url: "https://demo.twilio.com/welcome/sms/reply/",
         callback_method: "POST",
       },
       profile: {
         name: "Twilio",
         about: "Hello! We are Twilio.",
         address: "101 Spear Street, San Francisco, CA",
         description: "We're excited to see what you build!",
         logo_url: "https://www.twilio.com/logo.png",
         vertical: "Other",
         websites: ["https://twilio.com", "https://help.twilio.com"],
         emails: ["support@twilio.com"],
       },
     });

     console.log(channelsSender.sid);
   }

   createChannelsSender();
   ```

   ```python
   # Download the helper library from https://www.twilio.com/docs/python/install
   import os
   from twilio.rest import Client
   from twilio.rest.messaging.v2 import ChannelsSenderList

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = os.environ["TWILIO_API_KEY"]
   api_secret = os.environ["TWILIO_API_SECRET"]
   account_sid = os.environ["TWILIO_ACCOUNT_SID"]
   client = Client(api_key, api_secret, account_sid)

   channels_sender = client.messaging.v2.channels_senders.create(
       messaging_v2_channels_sender_requests_create=ChannelsSenderList.MessagingV2ChannelsSenderRequestsCreate(
           {
               "sender_id": "whatsapp:+15017122661",
               "configuration": ChannelsSenderList.MessagingV2ChannelsSenderConfiguration(
                   {"verification_method": "voice"}
               ),
               "webhook": ChannelsSenderList.MessagingV2ChannelsSenderWebhook(
                   {
                       "callback_url": "https://demo.twilio.com/welcome/sms/reply/",
                       "callback_method": "POST",
                   }
               ),
               "profile": ChannelsSenderList.MessagingV2ChannelsSenderProfile(
                   {
                       "name": "Twilio",
                       "about": "Hello! We are Twilio.",
                       "address": "101 Spear Street, San Francisco, CA",
                       "description": "We're excited to see what you build!",
                       "logo_url": "https://www.twilio.com/logo.png",
                       "vertical": "Other",
                       "websites": [
                           "https://twilio.com",
                           "https://help.twilio.com",
                       ],
                       "emails": ["support@twilio.com"],
                   }
               ),
           }
       )
   )

   print(channels_sender.sid)
   ```

   ```csharp
   // Install the C# / .NET helper library from twilio.com/docs/csharp/install

   using System;
   using Twilio;
   using Twilio.Rest.Messaging.V2;
   using System.Threading.Tasks;
   using System.Collections.Generic;

   class Program {
       public static async Task Main(string[] args) {
           // Find your Account SID at twilio.com/console
           // Provision API Keys at twilio.com/console/runtime/api-keys
           // and set the environment variables. See http://twil.io/secure
           // For local testing, you can use your Account SID and Auth token
           string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
           string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
           string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

           TwilioClient.Init(apiKey, apiSecret, accountSid);

           var channelsSender = await ChannelsSenderResource.CreateAsync(
               messagingV2ChannelsSenderRequestsCreate: new ChannelsSenderResource
                   .MessagingV2ChannelsSenderRequestsCreate.Builder()
                   .WithSenderId("whatsapp:+15017122661")
                   .WithConfiguration(
                       new ChannelsSenderResource.MessagingV2ChannelsSenderConfiguration.Builder()
                           .WithVerificationMethod("voice")
                           .Build())
                   .WithWebhook(new ChannelsSenderResource.MessagingV2ChannelsSenderWebhook.Builder()
                                    .WithCallbackUrl("https://demo.twilio.com/welcome/sms/reply/")
                                    .WithCallbackMethod("POST")
                                    .Build())
                   .WithProfile(
                       new ChannelsSenderResource.MessagingV2ChannelsSenderProfile.Builder()
                           .WithName("Twilio")
                           .WithAbout("Hello! We are Twilio.")
                           .WithAddress("101 Spear Street, San Francisco, CA")
                           .WithDescription("We're excited to see what you build!")
                           .WithLogoUrl("https://www.twilio.com/logo.png")
                           .WithVertical("Other")
                           .WithWebsites(
                               new List<string> { "https://twilio.com", "https://help.twilio.com" })
                           .WithEmails(new List<string> { "support@twilio.com" })
                           .Build())
                   .Build());

           Console.WriteLine(channelsSender.Sid);
       }
   }
   ```

   ```java
   // Install the Java helper library from twilio.com/docs/java/install

   import java.util.Arrays;
   import java.util.HashMap;
   import com.twilio.Twilio;
   import com.twilio.rest.messaging.v2.ChannelsSender;

   public class Example {
       // Find your Account SID at twilio.com/console
       // Provision API Keys at twilio.com/console/runtime/api-keys
       // and set the environment variables. See http://twil.io/secure
       // For local testing, you can use your Account SID and Auth token
       public static final String API_KEY = System.getenv("TWILIO_API_KEY");
       public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
       public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

       public static void main(String[] args) {
           Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);

           ChannelsSender.MessagingV2ChannelsSenderConfiguration configuration =
               new ChannelsSender.MessagingV2ChannelsSenderConfiguration();
           configuration.setVerificationMethod("voice");

           ChannelsSender.MessagingV2ChannelsSenderWebhook webhook = new ChannelsSender.MessagingV2ChannelsSenderWebhook();
           webhook.setCallbackUrl("https://demo.twilio.com/welcome/sms/reply/");
           webhook.setCallbackMethod("POST");

           ChannelsSender.MessagingV2ChannelsSenderProfile profile = new ChannelsSender.MessagingV2ChannelsSenderProfile();
           profile.setName("Twilio");
           profile.setAbout("Hello! We are Twilio.");
           profile.setAddress("101 Spear Street, San Francisco, CA");
           profile.setDescription("We're excited to see what you build!");
           profile.setLogoUrl("https://www.twilio.com/logo.png");
           profile.setVertical("Other");
           profile.setWebsites(Arrays.asList("https://twilio.com", "https://help.twilio.com"));
           profile.setEmails(Arrays.asList("support@twilio.com"));

           ChannelsSender.MessagingV2ChannelsSenderRequestsCreate messagingV2ChannelsSenderRequestsCreate =
               new ChannelsSender.MessagingV2ChannelsSenderRequestsCreate();
           messagingV2ChannelsSenderRequestsCreate.setSenderId("whatsapp:+15017122661");
           messagingV2ChannelsSenderRequestsCreate.setConfiguration(messagingV2ChannelsSenderConfiguration);
           messagingV2ChannelsSenderRequestsCreate.setWebhook(messagingV2ChannelsSenderWebhook);
           messagingV2ChannelsSenderRequestsCreate.setProfile(messagingV2ChannelsSenderProfile);

           ChannelsSender channelsSender = ChannelsSender.creator(messagingV2ChannelsSenderRequestsCreate).create();

           System.out.println(channelsSender.getSid());
       }
   }
   ```

   ```go
   // Download the helper library from https://www.twilio.com/docs/go/install
   package main

   import (
   	"fmt"
   	"github.com/twilio/twilio-go"
   	messaging "github.com/twilio/twilio-go/rest/messaging/v2"
   	"os"
   )

   func ptrOf[T any](v T) *T { return &v }

   func main() {
   	// Find your Account SID at twilio.com/console
   	// Provision API Keys at twilio.com/console/runtime/api-keys
   	// and set the environment variables. See http://twil.io/secure
   	// For local testing, you can use your Account SID and Auth token
   	accountSid := os.Getenv("TWILIO_ACCOUNT_SID")
   	apiKey := os.Getenv("TWILIO_API_KEY")
   	apiSecret := os.Getenv("TWILIO_API_SECRET")
   	client := twilio.NewRestClientWithParams(twilio.ClientParams{
   		Username:   apiKey,
   		Password:   apiSecret,
   		AccountSid: accountSid,
   	})

   	params := &messaging.CreateChannelsSenderParams{}
   	params.SetMessagingV2ChannelsSenderRequestsCreate(messaging.MessagingV2ChannelsSenderRequestsCreate{
   		SenderId: ptrOf("whatsapp:+15017122661"),
   		Configuration: &messaging.MessagingV2ChannelsSenderConfiguration{
   			VerificationMethod: ptrOf("voice"),
   		},
   		Webhook: &messaging.MessagingV2ChannelsSenderWebhook{
   			CallbackUrl:    ptrOf("https://demo.twilio.com/welcome/sms/reply/"),
   			CallbackMethod: ptrOf("POST"),
   		},
   		Profile: &messaging.MessagingV2ChannelsSenderProfile{
   			Name:        ptrOf("Twilio"),
   			About:       ptrOf("Hello! We are Twilio."),
   			Address:     ptrOf("101 Spear Street, San Francisco, CA"),
   			Description: ptrOf("We're excited to see what you build!"),
   			LogoUrl:     ptrOf("https://www.twilio.com/logo.png"),
   			Vertical:    ptrOf("Other"),
   			Websites: []string{
   				"https://twilio.com",
   				"https://help.twilio.com",
   			},
   			Emails: []string{
   				"support@twilio.com",
   			},
   		},
   	})

   	resp, err := client.MessagingV2.CreateChannelsSender(params)
   	if err != nil {
   		fmt.Println(err.Error())
   		os.Exit(1)
   	} else {
   		if resp.Sid != nil {
   			fmt.Println(*resp.Sid)
   		} else {
   			fmt.Println(resp.Sid)
   		}
   	}
   }
   ```

   ```php
   <?php

   // Update the path below to your autoload.php,
   // see https://getcomposer.org/doc/01-basic-usage.md
   require_once "/path/to/vendor/autoload.php";

   use Twilio\Rest\Client;
   use Twilio\Rest\Messaging\V2\ChannelsSenderModels;

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   $apiKey = $_ENV["TWILIO_API_KEY"];
   $apiSecret = $_ENV["TWILIO_API_SECRET"];
   $sid = $_ENV["TWILIO_ACCOUNT_SID"];
   $twilio = new Client($apiKey, $apiSecret, $sid);

   $channels_sender = $twilio->messaging->v2->channelsSenders->create(
       ChannelsSenderModels::createMessagingV2ChannelsSenderRequestsCreate([
           "senderId" => "whatsapp:+15017122661",
           "configuration" => ChannelsSenderModels::createMessagingV2ChannelsSenderConfiguration(
               [
                   "verificationMethod" => "voice",
               ],
           ),
           "webhook" => ChannelsSenderModels::createMessagingV2ChannelsSenderWebhook(
               [
                   "callbackUrl" => "https://demo.twilio.com/welcome/sms/reply/",
                   "callbackMethod" => "POST",
               ],
           ),
           "profile" => ChannelsSenderModels::createMessagingV2ChannelsSenderProfile(
               [
                   "name" => "Twilio",
                   "about" => "Hello! We are Twilio.",
                   "address" => "101 Spear Street, San Francisco, CA",
                   "description" => "We're excited to see what you build!",
                   "logoUrl" => "https://www.twilio.com/logo.png",
                   "vertical" => "Other",
                   "websites" => ["https://twilio.com", "https://help.twilio.com"],
                   "emails" => ["support@twilio.com"],
               ],
           ),
       ]),
   );

   print $channels_sender->sid;
   ```

   ```ruby
   # Download the helper library from https://www.twilio.com/docs/ruby/install
   require 'twilio-ruby'

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = ENV['TWILIO_API_KEY']
   api_secret = ENV['TWILIO_API_SECRET']
   account_sid = ENV['TWILIO_ACCOUNT_SID']
   @client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

   channels_sender = @client
                     .messaging
                     .v2
                     .channels_senders
                     .create(
                       messaging_v2_channels_sender_requests_create: {
                         'sender_id' => 'whatsapp:+15017122661',
                         'configuration' => {
                           'verification_method' => 'voice'
                         },
                         'webhook' => {
                           'callback_url' => 'https://demo.twilio.com/welcome/sms/reply/',
                           'callback_method' => 'POST'
                         },
                         'profile' => {
                           'name' => 'Twilio',
                           'about' => 'Hello! We are Twilio.',
                           'address' => '101 Spear Street, San Francisco, CA',
                           'description' => 'We\'re excited to see what you build!',
                           'logo_url' => 'https://www.twilio.com/logo.png',
                           'vertical' => 'Other',
                           'websites' => [
                             'https://twilio.com',
                             'https://help.twilio.com'
                           ],
                           'emails' => [
                             'support@twilio.com'
                           ]
                         }
                       }
                     )

   puts channels_sender.sid
   ```

   ```bash
   # This endpoint is not currently supported by the Twilio CLI. You can open an issue to request it on https://github.com/twilio/twilio-cli/issues
     # For an alternative low-code solution, check out https://www.twilio.com/docs/openapi/using-twilio-postman-collections
   ```

   ```bash
   EXCLAMATION_MARK='!'

   MESSAGING_V2_CHANNELS_SENDER_REQUESTS_CREATE_OBJ=$(cat << EOF
   {
     "sender_id": "whatsapp:+15017122661",
     "configuration": {
       "verification_method": "voice"
     },
     "webhook": {
       "callback_url": "https://demo.twilio.com/welcome/sms/reply/",
       "callback_method": "POST"
     },
     "profile": {
       "name": "Twilio",
       "about": "Hello$EXCLAMATION_MARK We are Twilio.",
       "address": "101 Spear Street, San Francisco, CA",
       "description": "We're excited to see what you build!",
       "logo_url": "https://www.twilio.com/logo.png",
       "vertical": "Other",
       "websites": [
         "https://twilio.com",
         "https://help.twilio.com"
       ],
       "emails": [
         "support@twilio.com"
       ]
     }
   }
   EOF
   )
   curl -X POST "https://messaging.twilio.com/v2/Channels/Senders" \
   --json "$MESSAGING_V2_CHANNELS_SENDER_REQUESTS_CREATE_OBJ" \
   -u $TWILIO_API_KEY:$TWILIO_API_SECRET
   ```

   ```json
   {
     "sid": "XEaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
     "status": "CREATING",
     "sender_id": "whatsapp:+15017122661",
     "configuration": {
       "verification_method": "voice"
     },
     "webhook": {
       "callback_url": "https://demo.twilio.com/welcome/sms/reply/",
       "callback_method": "POST"
     },
     "profile": {
       "name": "Twilio",
       "about": "Hello! We are Twilio.",
       "address": "101 Spear Street, San Francisco, CA",
       "description": "We're excited to see what you build!",
       "logo_url": "https://www.twilio.com/logo.png",
       "vertical": "Other",
       "websites": [
         "https://twilio.com",
         "https://help.twilio.com"
       ],
       "emails": [
         "support@twilio.com"
       ]
     }
   }
   ```

   This request creates a WhatsApp sender in Twilio's system, adds it to the WABA connected to your Twilio account, and triggers the OTP from Meta.
4. To verify the phone number, make a `POST /v2/Channels/Senders/{Sid}` request with the OTP received via email.

   Verify the phone number

   ```js
   // Download the helper library from https://www.twilio.com/docs/node/install
   const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   const accountSid = process.env.TWILIO_ACCOUNT_SID;
   const apiKey = process.env.TWILIO_API_KEY;
   const apiSecret = process.env.TWILIO_API_SECRET;
   const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

   async function updateChannelsSender() {
     const channelsSender = await client.messaging.v2
       .channelsSenders("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
       .update({
         configuration: {
           verification_code: "123456",
         },
       });

     console.log(channelsSender.sid);
   }

   updateChannelsSender();
   ```

   ```python
   # Download the helper library from https://www.twilio.com/docs/python/install
   import os
   from twilio.rest import Client
   from twilio.rest.messaging.v2 import ChannelsSenderList

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = os.environ["TWILIO_API_KEY"]
   api_secret = os.environ["TWILIO_API_SECRET"]
   account_sid = os.environ["TWILIO_ACCOUNT_SID"]
   client = Client(api_key, api_secret, account_sid)

   channels_sender = client.messaging.v2.channels_senders(
       "XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
   ).update(
       messaging_v2_channels_sender_requests_update=ChannelsSenderList.MessagingV2ChannelsSenderRequestsUpdate(
           {
               "configuration": ChannelsSenderList.MessagingV2ChannelsSenderConfiguration(
                   {"verification_code": "123456"}
               )
           }
       )
   )

   print(channels_sender.sid)
   ```

   ```csharp
   // Install the C# / .NET helper library from twilio.com/docs/csharp/install

   using System;
   using Twilio;
   using Twilio.Rest.Messaging.V2;
   using System.Threading.Tasks;
   using System.Collections.Generic;

   class Program {
       public static async Task Main(string[] args) {
           // Find your Account SID at twilio.com/console
           // Provision API Keys at twilio.com/console/runtime/api-keys
           // and set the environment variables. See http://twil.io/secure
           // For local testing, you can use your Account SID and Auth token
           string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
           string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
           string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

           TwilioClient.Init(apiKey, apiSecret, accountSid);

           var channelsSender = await ChannelsSenderResource.UpdateAsync(
               new UpdateChannelsSenderOptions("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") {
                   MessagingV2ChannelsSenderRequestsUpdate =
                       new ChannelsSenderResource.MessagingV2ChannelsSenderRequestsUpdate.Builder()
                           .WithConfiguration(
                               new ChannelsSenderResource.MessagingV2ChannelsSenderConfiguration
                                   .Builder()
                                   .WithVerificationCode("123456")
                                   .Build())
                           .Build()
               });

           Console.WriteLine(channelsSender.Sid);
       }
   }
   ```

   ```java
   // Install the Java helper library from twilio.com/docs/java/install

   import java.util.Arrays;
   import java.util.HashMap;
   import com.twilio.Twilio;
   import com.twilio.rest.messaging.v2.ChannelsSender;

   public class Example {
       // Find your Account SID at twilio.com/console
       // Provision API Keys at twilio.com/console/runtime/api-keys
       // and set the environment variables. See http://twil.io/secure
       // For local testing, you can use your Account SID and Auth token
       public static final String API_KEY = System.getenv("TWILIO_API_KEY");
       public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
       public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

       public static void main(String[] args) {
           Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);

           ChannelsSender.MessagingV2ChannelsSenderConfiguration configuration =
               new ChannelsSender.MessagingV2ChannelsSenderConfiguration();
           configuration.setVerificationCode("123456");

           ChannelsSender.MessagingV2ChannelsSenderRequestsUpdate messagingV2ChannelsSenderRequestsUpdate =
               new ChannelsSender.MessagingV2ChannelsSenderRequestsUpdate();
           messagingV2ChannelsSenderRequestsUpdate.setConfiguration(messagingV2ChannelsSenderConfiguration);

           ChannelsSender channelsSender =
               ChannelsSender.updater("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", messagingV2ChannelsSenderRequestsUpdate)
                   .update();

           System.out.println(channelsSender.getSid());
       }
   }
   ```

   ```go
   // Download the helper library from https://www.twilio.com/docs/go/install
   package main

   import (
   	"fmt"
   	"github.com/twilio/twilio-go"
   	messaging "github.com/twilio/twilio-go/rest/messaging/v2"
   	"os"
   )

   func ptrOf[T any](v T) *T { return &v }

   func main() {
   	// Find your Account SID at twilio.com/console
   	// Provision API Keys at twilio.com/console/runtime/api-keys
   	// and set the environment variables. See http://twil.io/secure
   	// For local testing, you can use your Account SID and Auth token
   	accountSid := os.Getenv("TWILIO_ACCOUNT_SID")
   	apiKey := os.Getenv("TWILIO_API_KEY")
   	apiSecret := os.Getenv("TWILIO_API_SECRET")
   	client := twilio.NewRestClientWithParams(twilio.ClientParams{
   		Username:   apiKey,
   		Password:   apiSecret,
   		AccountSid: accountSid,
   	})

   	params := &messaging.UpdateChannelsSenderParams{}
   	params.SetMessagingV2ChannelsSenderRequestsUpdate(messaging.MessagingV2ChannelsSenderRequestsUpdate{
   		Configuration: &messaging.MessagingV2ChannelsSenderConfiguration{
   			VerificationCode: ptrOf("123456"),
   		},
   	})

   	resp, err := client.MessagingV2.UpdateChannelsSender("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
   		params)
   	if err != nil {
   		fmt.Println(err.Error())
   		os.Exit(1)
   	} else {
   		if resp.Sid != nil {
   			fmt.Println(*resp.Sid)
   		} else {
   			fmt.Println(resp.Sid)
   		}
   	}
   }
   ```

   ```php
   <?php

   // Update the path below to your autoload.php,
   // see https://getcomposer.org/doc/01-basic-usage.md
   require_once "/path/to/vendor/autoload.php";

   use Twilio\Rest\Client;
   use Twilio\Rest\Messaging\V2\ChannelsSenderModels;

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   $apiKey = $_ENV["TWILIO_API_KEY"];
   $apiSecret = $_ENV["TWILIO_API_SECRET"];
   $sid = $_ENV["TWILIO_ACCOUNT_SID"];
   $twilio = new Client($apiKey, $apiSecret, $sid);

   $channels_sender = $twilio->messaging->v2
       ->channelsSenders("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
       ->update(
           ChannelsSenderModels::createMessagingV2ChannelsSenderRequestsUpdate([
               "configuration" => ChannelsSenderModels::createMessagingV2ChannelsSenderConfiguration(
                   [
                       "verificationCode" => "123456",
                   ],
               ),
           ]),
       );

   print $channels_sender->sid;
   ```

   ```ruby
   # Download the helper library from https://www.twilio.com/docs/ruby/install
   require 'twilio-ruby'

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = ENV['TWILIO_API_KEY']
   api_secret = ENV['TWILIO_API_SECRET']
   account_sid = ENV['TWILIO_ACCOUNT_SID']
   @client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

   channels_sender = @client
                     .messaging
                     .v2
                     .channels_senders('XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                     .update(
                       messaging_v2_channels_sender_requests_update: {
                         'configuration' => {
                           'verification_code' => '123456'
                         }
                       }
                     )

   puts channels_sender.sid
   ```

   ```bash
   # This endpoint is not currently supported by the Twilio CLI. You can open an issue to request it on https://github.com/twilio/twilio-cli/issues
     # For an alternative low-code solution, check out https://www.twilio.com/docs/openapi/using-twilio-postman-collections
   ```

   ```bash
   MESSAGING_V2_CHANNELS_SENDER_REQUESTS_UPDATE_OBJ=$(cat << EOF
   {
     "configuration": {
       "verification_code": "123456"
     }
   }
   EOF
   )
   curl -X POST "https://messaging.twilio.com/v2/Channels/Senders/XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
   --json "$MESSAGING_V2_CHANNELS_SENDER_REQUESTS_UPDATE_OBJ" \
   -u $TWILIO_API_KEY:$TWILIO_API_SECRET
   ```

   ```json
   {
     "sid": "XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
     "status": "VERIFYING",
     "sender_id": "whatsapp:+999999999XX",
     "friendly_name": null,
     "compliance": null,
     "configuration": {
       "verification_code": "123456"
     },
     "webhook": {
       "callback_url": "https://callback.example.com",
       "callback_method": "POST",
       "fallback_url": "https://fallback.example.com",
       "fallback_method": "POST",
       "status_callback_url": "https://statuscallback.example.com",
       "status_callback_method": "POST"
     },
     "profile": {
       "about": "Example about text",
       "address": "123 Example St, Example City, EX 12345",
       "description": "Example description",
       "emails": [
         {
           "email": "email@email.com",
           "label": "Email"
         }
       ],
       "name": "Example Business",
       "logo_url": "https://logo_url.example.com",
       "vertical": "Automotive",
       "websites": [
         {
           "website": "https://website1.example.com",
           "label": "Website"
         },
         {
           "website": "http://website2.example.com",
           "label": "Website"
         }
       ],
       "banner_url": null,
       "privacy_url": null,
       "terms_of_service_url": null,
       "accent_color": null,
       "phone_numbers": null
     },
     "display_name_status": "updating"
   }
   ```
5. To confirm the WhatsApp sender is registered, make a `GET v2/Channels/Senders/{Sid}` request and check if `status` is `ONLINE`.\
   **Note**: Immediately after registration, the `status` value will be `OFFLINE`. Wait a few minutes, then make the request again.

   Confirm WhatsApp sender registration

   ```js
   // Download the helper library from https://www.twilio.com/docs/node/install
   const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   const accountSid = process.env.TWILIO_ACCOUNT_SID;
   const apiKey = process.env.TWILIO_API_KEY;
   const apiSecret = process.env.TWILIO_API_SECRET;
   const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

   async function fetchChannelsSender() {
     const channelsSender = await client.messaging.v2
       .channelsSenders("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
       .fetch();

     console.log(channelsSender.sid);
   }

   fetchChannelsSender();
   ```

   ```python
   # Download the helper library from https://www.twilio.com/docs/python/install
   import os
   from twilio.rest import Client

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = os.environ["TWILIO_API_KEY"]
   api_secret = os.environ["TWILIO_API_SECRET"]
   account_sid = os.environ["TWILIO_ACCOUNT_SID"]
   client = Client(api_key, api_secret, account_sid)

   channels_sender = client.messaging.v2.channels_senders(
       "XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
   ).fetch()

   print(channels_sender.sid)
   ```

   ```csharp
   // Install the C# / .NET helper library from twilio.com/docs/csharp/install

   using System;
   using Twilio;
   using Twilio.Rest.Messaging.V2;
   using System.Threading.Tasks;

   class Program {
       public static async Task Main(string[] args) {
           // Find your Account SID at twilio.com/console
           // Provision API Keys at twilio.com/console/runtime/api-keys
           // and set the environment variables. See http://twil.io/secure
           // For local testing, you can use your Account SID and Auth token
           string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
           string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
           string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

           TwilioClient.Init(apiKey, apiSecret, accountSid);

           var channelsSender =
               await ChannelsSenderResource.FetchAsync(pathSid: "XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");

           Console.WriteLine(channelsSender.Sid);
       }
   }
   ```

   ```java
   // Install the Java helper library from twilio.com/docs/java/install

   import com.twilio.Twilio;
   import com.twilio.rest.messaging.v2.ChannelsSender;

   public class Example {
       // Find your Account SID at twilio.com/console
       // Provision API Keys at twilio.com/console/runtime/api-keys
       // and set the environment variables. See http://twil.io/secure
       // For local testing, you can use your Account SID and Auth token
       public static final String API_KEY = System.getenv("TWILIO_API_KEY");
       public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
       public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

       public static void main(String[] args) {
           Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);
           ChannelsSender channelsSender = ChannelsSender.fetcher("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX").fetch();

           System.out.println(channelsSender.getSid());
       }
   }
   ```

   ```go
   // Download the helper library from https://www.twilio.com/docs/go/install
   package main

   import (
   	"fmt"
   	"github.com/twilio/twilio-go"
   	"os"
   )

   func main() {
   	// Find your Account SID at twilio.com/console
   	// Provision API Keys at twilio.com/console/runtime/api-keys
   	// and set the environment variables. See http://twil.io/secure
   	// For local testing, you can use your Account SID and Auth token
   	accountSid := os.Getenv("TWILIO_ACCOUNT_SID")
   	apiKey := os.Getenv("TWILIO_API_KEY")
   	apiSecret := os.Getenv("TWILIO_API_SECRET")
   	client := twilio.NewRestClientWithParams(twilio.ClientParams{
   		Username:   apiKey,
   		Password:   apiSecret,
   		AccountSid: accountSid,
   	})

   	resp, err := client.MessagingV2.FetchChannelsSender("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
   	if err != nil {
   		fmt.Println(err.Error())
   		os.Exit(1)
   	} else {
   		if resp.Sid != nil {
   			fmt.Println(*resp.Sid)
   		} else {
   			fmt.Println(resp.Sid)
   		}
   	}
   }
   ```

   ```php
   <?php

   // Update the path below to your autoload.php,
   // see https://getcomposer.org/doc/01-basic-usage.md
   require_once "/path/to/vendor/autoload.php";

   use Twilio\Rest\Client;

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   $apiKey = $_ENV["TWILIO_API_KEY"];
   $apiSecret = $_ENV["TWILIO_API_SECRET"];
   $sid = $_ENV["TWILIO_ACCOUNT_SID"];
   $twilio = new Client($apiKey, $apiSecret, $sid);

   $channels_sender = $twilio->messaging->v2
       ->channelsSenders("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
       ->fetch();

   print $channels_sender->sid;
   ```

   ```ruby
   # Download the helper library from https://www.twilio.com/docs/ruby/install
   require 'twilio-ruby'

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = ENV['TWILIO_API_KEY']
   api_secret = ENV['TWILIO_API_SECRET']
   account_sid = ENV['TWILIO_ACCOUNT_SID']
   @client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

   channels_sender = @client
                     .messaging
                     .v2
                     .channels_senders('XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                     .fetch

   puts channels_sender.sid
   ```

   ```bash
   # Install the twilio-cli from https://twil.io/cli

   twilio api:messaging:v2:channels:senders:fetch \
      --sid XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   ```

   ```bash
   curl -X GET "https://messaging.twilio.com/v2/Channels/Senders/XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
   -u $TWILIO_API_KEY:$TWILIO_API_SECRET
   ```

   ```json
   {
     "sid": "XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
     "status": "ONLINE",
     "sender_id": "whatsapp:+999999999XX",
     "configuration": {
       "waba_id": "1234567XXX",
       "verification_method": null,
       "verification_code": null,
       "voice_application_sid": "APXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
       "account_type": null
     },
     "webhook": {
       "callback_url": "https://callback.example.com",
       "callback_method": "POST",
       "fallback_url": "https://fallback.example.com",
       "fallback_method": "POST",
       "status_callback_url": "https://statuscallback.example.com",
       "status_callback_method": "POST"
     },
     "profile": {
       "name": "Example Profile Name",
       "about": "This is an example about text.",
       "address": "123 Example St, Example City, EX 12345",
       "description": "This is an example description.",
       "emails": [
         {
           "email": "email@email.com",
           "label": "Email"
         }
       ],
       "logo_url": "https://logo_url.example.com",
       "vertical": "Automotive",
       "websites": [
         {
           "website": "https://website1.example.com",
           "label": "Website"
         },
         {
           "website": "http://website2.example.com",
           "label": "Website"
         }
       ],
       "banner_url": null,
       "privacy_url": null,
       "terms_of_service_url": null,
       "accent_color": null,
       "use_case": null,
       "phone_numbers": null
     },
     "compliance": null,
     "properties": {
       "quality_rating": "HIGH",
       "messaging_limit": "10K Customers/24hr"
     },
     "offline_reasons": null,
     "url": "https://messaging.twilio.com/v2/Channels/Senders/XEaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
   }
   ```

## New Twilio console

1. Go to [Numbers & senders](https://1console.twilio.com/go?to=/account/__account__/us1/senders-hub/list/phone-numbers/inventory) and select the number you'd like to connect to the Flow. If you don't have any phone numbers, click **Set up a new phone number**.
2. Select the *Configuration details* tab.
3. Select **Messaging**, then click **Edit details**.
4. On the *Edit messaging configuration* dialog, select the **Webhook, TwiML Bin, Function, Studio Flow, Proxy Service** option.
5. Under *How do you want to set up your primary method?*, select **Webhook**.
6. Paste the following webhook into the page, replacing `<YOUR_EMAIL_ADDRESS>` with your email address: `https://twimlets.com/voicemail?Email=<YOUR_EMAIL_ADDRESS>`.
   For example, `https://twimlets.com/voicemail?Email=support@example.com`. The [Voicemail Twimlet](https://console.twilio.com/us1/develop/twimlets/create?twimlet=voicemail) transcribes incoming calls and sends the transcription to your email address. This allows you to receive OTPs via email.

## Legacy console

1. Open the [Active Numbers page (legacy console)](https://www.twilio.com/console/phone-numbers/incoming).
2. Click your Twilio phone number.
3. In the **Voice Configuration** section, in the **Configure with** row, select **Webhook, TwiML Bin, Function, Studio Flow, Proxy Service**.
4. In the **A call comes in** row, select **Webhook** and set the **URL** to `https://twimlets.com/voicemail?Email=<YOUR_EMAIL_ADDRESS>`. For example, `https://twimlets.com/voicemail?Email=support@example.com`.\
   **Note**: The [Voicemail Twimlet](https://console.twilio.com/us1/develop/twimlets/create?twimlet=voicemail) transcribes incoming calls and sends the transcription to your email address. This allows you to receive OTPs via email.

## SMS: Non-Twilio phone number

1. Make sure your phone number meets all [requirements](#phone-number-requirements) and can receive SMS messages.
2. To register a WhatsApp sender, make a `POST /v2/Channels/Senders` request. The following properties are required in the request body:

   * `sender_id`: The phone number to register as a WhatsApp sender in [E.164 format](/docs/glossary/what-e164)
   * `profile.name`: The [WhatsApp sender display name](#display-name-requirements)

   For additional properties, see the [Senders API documentation](/docs/whatsapp/api/senders).

   > \[!WARNING]
   >
   > Allow several minutes between Senders API requests. Too many requests in a short period might result in errors.

   Register a WhatsApp sender (SMS: Non-Twilio phone number)

   ```js
   // Download the helper library from https://www.twilio.com/docs/node/install
   const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   const accountSid = process.env.TWILIO_ACCOUNT_SID;
   const apiKey = process.env.TWILIO_API_KEY;
   const apiSecret = process.env.TWILIO_API_SECRET;
   const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

   async function createChannelsSender() {
     const channelsSender = await client.messaging.v2.channelsSenders.create({
       sender_id: "whatsapp:+15017122661",
       webhook: {
         callback_url: "https://demo.twilio.com/welcome/sms/reply/",
         callback_method: "POST",
       },
       profile: {
         name: "Twilio",
         about: "Hello! We are Twilio.",
         address: "101 Spear Street, San Francisco, CA",
         description: "We're excited to see what you build!",
         logo_url: "https://www.twilio.com/logo.png",
         vertical: "Other",
         websites: ["https://twilio.com", "https://help.twilio.com"],
         emails: ["support@twilio.com"],
       },
     });

     console.log(channelsSender.sid);
   }

   createChannelsSender();
   ```

   ```python
   # Download the helper library from https://www.twilio.com/docs/python/install
   import os
   from twilio.rest import Client
   from twilio.rest.messaging.v2 import ChannelsSenderList

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = os.environ["TWILIO_API_KEY"]
   api_secret = os.environ["TWILIO_API_SECRET"]
   account_sid = os.environ["TWILIO_ACCOUNT_SID"]
   client = Client(api_key, api_secret, account_sid)

   channels_sender = client.messaging.v2.channels_senders.create(
       messaging_v2_channels_sender_requests_create=ChannelsSenderList.MessagingV2ChannelsSenderRequestsCreate(
           {
               "sender_id": "whatsapp:+15017122661",
               "webhook": ChannelsSenderList.MessagingV2ChannelsSenderWebhook(
                   {
                       "callback_url": "https://demo.twilio.com/welcome/sms/reply/",
                       "callback_method": "POST",
                   }
               ),
               "profile": ChannelsSenderList.MessagingV2ChannelsSenderProfile(
                   {
                       "name": "Twilio",
                       "about": "Hello! We are Twilio.",
                       "address": "101 Spear Street, San Francisco, CA",
                       "description": "We're excited to see what you build!",
                       "logo_url": "https://www.twilio.com/logo.png",
                       "vertical": "Other",
                       "websites": [
                           "https://twilio.com",
                           "https://help.twilio.com",
                       ],
                       "emails": ["support@twilio.com"],
                   }
               ),
           }
       )
   )

   print(channels_sender.sid)
   ```

   ```csharp
   // Install the C# / .NET helper library from twilio.com/docs/csharp/install

   using System;
   using Twilio;
   using Twilio.Rest.Messaging.V2;
   using System.Threading.Tasks;
   using System.Collections.Generic;

   class Program {
       public static async Task Main(string[] args) {
           // Find your Account SID at twilio.com/console
           // Provision API Keys at twilio.com/console/runtime/api-keys
           // and set the environment variables. See http://twil.io/secure
           // For local testing, you can use your Account SID and Auth token
           string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
           string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
           string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

           TwilioClient.Init(apiKey, apiSecret, accountSid);

           var channelsSender = await ChannelsSenderResource.CreateAsync(
               messagingV2ChannelsSenderRequestsCreate: new ChannelsSenderResource
                   .MessagingV2ChannelsSenderRequestsCreate.Builder()
                   .WithSenderId("whatsapp:+15017122661")
                   .WithWebhook(new ChannelsSenderResource.MessagingV2ChannelsSenderWebhook.Builder()
                                    .WithCallbackUrl("https://demo.twilio.com/welcome/sms/reply/")
                                    .WithCallbackMethod("POST")
                                    .Build())
                   .WithProfile(
                       new ChannelsSenderResource.MessagingV2ChannelsSenderProfile.Builder()
                           .WithName("Twilio")
                           .WithAbout("Hello! We are Twilio.")
                           .WithAddress("101 Spear Street, San Francisco, CA")
                           .WithDescription("We're excited to see what you build!")
                           .WithLogoUrl("https://www.twilio.com/logo.png")
                           .WithVertical("Other")
                           .WithWebsites(
                               new List<string> { "https://twilio.com", "https://help.twilio.com" })
                           .WithEmails(new List<string> { "support@twilio.com" })
                           .Build())
                   .Build());

           Console.WriteLine(channelsSender.Sid);
       }
   }
   ```

   ```java
   // Install the Java helper library from twilio.com/docs/java/install

   import java.util.Arrays;
   import java.util.HashMap;
   import com.twilio.Twilio;
   import com.twilio.rest.messaging.v2.ChannelsSender;

   public class Example {
       // Find your Account SID at twilio.com/console
       // Provision API Keys at twilio.com/console/runtime/api-keys
       // and set the environment variables. See http://twil.io/secure
       // For local testing, you can use your Account SID and Auth token
       public static final String API_KEY = System.getenv("TWILIO_API_KEY");
       public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
       public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

       public static void main(String[] args) {
           Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);

           ChannelsSender.MessagingV2ChannelsSenderWebhook webhook = new ChannelsSender.MessagingV2ChannelsSenderWebhook();
           webhook.setCallbackUrl("https://demo.twilio.com/welcome/sms/reply/");
           webhook.setCallbackMethod("POST");

           ChannelsSender.MessagingV2ChannelsSenderProfile profile = new ChannelsSender.MessagingV2ChannelsSenderProfile();
           profile.setName("Twilio");
           profile.setAbout("Hello! We are Twilio.");
           profile.setAddress("101 Spear Street, San Francisco, CA");
           profile.setDescription("We're excited to see what you build!");
           profile.setLogoUrl("https://www.twilio.com/logo.png");
           profile.setVertical("Other");
           profile.setWebsites(Arrays.asList("https://twilio.com", "https://help.twilio.com"));
           profile.setEmails(Arrays.asList("support@twilio.com"));

           ChannelsSender.MessagingV2ChannelsSenderRequestsCreate messagingV2ChannelsSenderRequestsCreate =
               new ChannelsSender.MessagingV2ChannelsSenderRequestsCreate();
           messagingV2ChannelsSenderRequestsCreate.setSenderId("whatsapp:+15017122661");
           messagingV2ChannelsSenderRequestsCreate.setWebhook(messagingV2ChannelsSenderWebhook);
           messagingV2ChannelsSenderRequestsCreate.setProfile(messagingV2ChannelsSenderProfile);

           ChannelsSender channelsSender = ChannelsSender.creator(messagingV2ChannelsSenderRequestsCreate).create();

           System.out.println(channelsSender.getSid());
       }
   }
   ```

   ```go
   // Download the helper library from https://www.twilio.com/docs/go/install
   package main

   import (
   	"fmt"
   	"github.com/twilio/twilio-go"
   	messaging "github.com/twilio/twilio-go/rest/messaging/v2"
   	"os"
   )

   func ptrOf[T any](v T) *T { return &v }

   func main() {
   	// Find your Account SID at twilio.com/console
   	// Provision API Keys at twilio.com/console/runtime/api-keys
   	// and set the environment variables. See http://twil.io/secure
   	// For local testing, you can use your Account SID and Auth token
   	accountSid := os.Getenv("TWILIO_ACCOUNT_SID")
   	apiKey := os.Getenv("TWILIO_API_KEY")
   	apiSecret := os.Getenv("TWILIO_API_SECRET")
   	client := twilio.NewRestClientWithParams(twilio.ClientParams{
   		Username:   apiKey,
   		Password:   apiSecret,
   		AccountSid: accountSid,
   	})

   	params := &messaging.CreateChannelsSenderParams{}
   	params.SetMessagingV2ChannelsSenderRequestsCreate(messaging.MessagingV2ChannelsSenderRequestsCreate{
   		SenderId: ptrOf("whatsapp:+15017122661"),
   		Webhook: &messaging.MessagingV2ChannelsSenderWebhook{
   			CallbackUrl:    ptrOf("https://demo.twilio.com/welcome/sms/reply/"),
   			CallbackMethod: ptrOf("POST"),
   		},
   		Profile: &messaging.MessagingV2ChannelsSenderProfile{
   			Name:        ptrOf("Twilio"),
   			About:       ptrOf("Hello! We are Twilio."),
   			Address:     ptrOf("101 Spear Street, San Francisco, CA"),
   			Description: ptrOf("We're excited to see what you build!"),
   			LogoUrl:     ptrOf("https://www.twilio.com/logo.png"),
   			Vertical:    ptrOf("Other"),
   			Websites: []string{
   				"https://twilio.com",
   				"https://help.twilio.com",
   			},
   			Emails: []string{
   				"support@twilio.com",
   			},
   		},
   	})

   	resp, err := client.MessagingV2.CreateChannelsSender(params)
   	if err != nil {
   		fmt.Println(err.Error())
   		os.Exit(1)
   	} else {
   		if resp.Sid != nil {
   			fmt.Println(*resp.Sid)
   		} else {
   			fmt.Println(resp.Sid)
   		}
   	}
   }
   ```

   ```php
   <?php

   // Update the path below to your autoload.php,
   // see https://getcomposer.org/doc/01-basic-usage.md
   require_once "/path/to/vendor/autoload.php";

   use Twilio\Rest\Client;
   use Twilio\Rest\Messaging\V2\ChannelsSenderModels;

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   $apiKey = $_ENV["TWILIO_API_KEY"];
   $apiSecret = $_ENV["TWILIO_API_SECRET"];
   $sid = $_ENV["TWILIO_ACCOUNT_SID"];
   $twilio = new Client($apiKey, $apiSecret, $sid);

   $channels_sender = $twilio->messaging->v2->channelsSenders->create(
       ChannelsSenderModels::createMessagingV2ChannelsSenderRequestsCreate([
           "senderId" => "whatsapp:+15017122661",
           "webhook" => ChannelsSenderModels::createMessagingV2ChannelsSenderWebhook(
               [
                   "callbackUrl" => "https://demo.twilio.com/welcome/sms/reply/",
                   "callbackMethod" => "POST",
               ],
           ),
           "profile" => ChannelsSenderModels::createMessagingV2ChannelsSenderProfile(
               [
                   "name" => "Twilio",
                   "about" => "Hello! We are Twilio.",
                   "address" => "101 Spear Street, San Francisco, CA",
                   "description" => "We're excited to see what you build!",
                   "logoUrl" => "https://www.twilio.com/logo.png",
                   "vertical" => "Other",
                   "websites" => ["https://twilio.com", "https://help.twilio.com"],
                   "emails" => ["support@twilio.com"],
               ],
           ),
       ]),
   );

   print $channels_sender->sid;
   ```

   ```ruby
   # Download the helper library from https://www.twilio.com/docs/ruby/install
   require 'twilio-ruby'

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = ENV['TWILIO_API_KEY']
   api_secret = ENV['TWILIO_API_SECRET']
   account_sid = ENV['TWILIO_ACCOUNT_SID']
   @client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

   channels_sender = @client
                     .messaging
                     .v2
                     .channels_senders
                     .create(
                       messaging_v2_channels_sender_requests_create: {
                         'sender_id' => 'whatsapp:+15017122661',
                         'webhook' => {
                           'callback_url' => 'https://demo.twilio.com/welcome/sms/reply/',
                           'callback_method' => 'POST'
                         },
                         'profile' => {
                           'name' => 'Twilio',
                           'about' => 'Hello! We are Twilio.',
                           'address' => '101 Spear Street, San Francisco, CA',
                           'description' => 'We\'re excited to see what you build!',
                           'logo_url' => 'https://www.twilio.com/logo.png',
                           'vertical' => 'Other',
                           'websites' => [
                             'https://twilio.com',
                             'https://help.twilio.com'
                           ],
                           'emails' => [
                             'support@twilio.com'
                           ]
                         }
                       }
                     )

   puts channels_sender.sid
   ```

   ```bash
   # This endpoint is not currently supported by the Twilio CLI. You can open an issue to request it on https://github.com/twilio/twilio-cli/issues
     # For an alternative low-code solution, check out https://www.twilio.com/docs/openapi/using-twilio-postman-collections
   ```

   ```bash
   EXCLAMATION_MARK='!'

   MESSAGING_V2_CHANNELS_SENDER_REQUESTS_CREATE_OBJ=$(cat << EOF
   {
     "sender_id": "whatsapp:+15017122661",
     "webhook": {
       "callback_url": "https://demo.twilio.com/welcome/sms/reply/",
       "callback_method": "POST"
     },
     "profile": {
       "name": "Twilio",
       "about": "Hello$EXCLAMATION_MARK We are Twilio.",
       "address": "101 Spear Street, San Francisco, CA",
       "description": "We're excited to see what you build!",
       "logo_url": "https://www.twilio.com/logo.png",
       "vertical": "Other",
       "websites": [
         "https://twilio.com",
         "https://help.twilio.com"
       ],
       "emails": [
         "support@twilio.com"
       ]
     }
   }
   EOF
   )
   curl -X POST "https://messaging.twilio.com/v2/Channels/Senders" \
   --json "$MESSAGING_V2_CHANNELS_SENDER_REQUESTS_CREATE_OBJ" \
   -u $TWILIO_API_KEY:$TWILIO_API_SECRET
   ```

   ```json
   {
     "sid": "XEaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
     "status": "CREATING",
     "sender_id": "whatsapp:+15017122661",
     "configuration": {
       "waba_id": "1234567XXX",
       "verification_method": "sms",
       "verification_code": null,
       "voice_application_sid": "APXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
       "account_type": null
     },
     "webhook": {
       "callback_url": "https://demo.twilio.com/welcome/sms/reply/",
       "callback_method": "POST"
     },
     "profile": {
       "name": "Twilio",
       "about": "Hello! We are Twilio.",
       "address": "101 Spear Street, San Francisco, CA",
       "description": "We're excited to see what you build!",
       "logo_url": "https://www.twilio.com/logo.png",
       "vertical": "Other",
       "websites": [
         "https://twilio.com",
         "https://help.twilio.com"
       ],
       "emails": [
         "support@twilio.com"
       ]
     }
   }
   ```

   This request creates a WhatsApp sender in Twilio's system, adds it to the WABA connected to your Twilio account, and triggers the OTP from Meta.
3. To verify the phone number, make a `POST /v2/Channels/Senders/{Sid}` request with the OTP received via SMS.

   Verify the phone number

   ```js
   // Download the helper library from https://www.twilio.com/docs/node/install
   const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   const accountSid = process.env.TWILIO_ACCOUNT_SID;
   const apiKey = process.env.TWILIO_API_KEY;
   const apiSecret = process.env.TWILIO_API_SECRET;
   const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

   async function updateChannelsSender() {
     const channelsSender = await client.messaging.v2
       .channelsSenders("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
       .update({
         configuration: {
           verification_code: "123456",
         },
       });

     console.log(channelsSender.sid);
   }

   updateChannelsSender();
   ```

   ```python
   # Download the helper library from https://www.twilio.com/docs/python/install
   import os
   from twilio.rest import Client
   from twilio.rest.messaging.v2 import ChannelsSenderList

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = os.environ["TWILIO_API_KEY"]
   api_secret = os.environ["TWILIO_API_SECRET"]
   account_sid = os.environ["TWILIO_ACCOUNT_SID"]
   client = Client(api_key, api_secret, account_sid)

   channels_sender = client.messaging.v2.channels_senders(
       "XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
   ).update(
       messaging_v2_channels_sender_requests_update=ChannelsSenderList.MessagingV2ChannelsSenderRequestsUpdate(
           {
               "configuration": ChannelsSenderList.MessagingV2ChannelsSenderConfiguration(
                   {"verification_code": "123456"}
               )
           }
       )
   )

   print(channels_sender.sid)
   ```

   ```csharp
   // Install the C# / .NET helper library from twilio.com/docs/csharp/install

   using System;
   using Twilio;
   using Twilio.Rest.Messaging.V2;
   using System.Threading.Tasks;
   using System.Collections.Generic;

   class Program {
       public static async Task Main(string[] args) {
           // Find your Account SID at twilio.com/console
           // Provision API Keys at twilio.com/console/runtime/api-keys
           // and set the environment variables. See http://twil.io/secure
           // For local testing, you can use your Account SID and Auth token
           string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
           string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
           string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

           TwilioClient.Init(apiKey, apiSecret, accountSid);

           var channelsSender = await ChannelsSenderResource.UpdateAsync(
               new UpdateChannelsSenderOptions("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") {
                   MessagingV2ChannelsSenderRequestsUpdate =
                       new ChannelsSenderResource.MessagingV2ChannelsSenderRequestsUpdate.Builder()
                           .WithConfiguration(
                               new ChannelsSenderResource.MessagingV2ChannelsSenderConfiguration
                                   .Builder()
                                   .WithVerificationCode("123456")
                                   .Build())
                           .Build()
               });

           Console.WriteLine(channelsSender.Sid);
       }
   }
   ```

   ```java
   // Install the Java helper library from twilio.com/docs/java/install

   import java.util.Arrays;
   import java.util.HashMap;
   import com.twilio.Twilio;
   import com.twilio.rest.messaging.v2.ChannelsSender;

   public class Example {
       // Find your Account SID at twilio.com/console
       // Provision API Keys at twilio.com/console/runtime/api-keys
       // and set the environment variables. See http://twil.io/secure
       // For local testing, you can use your Account SID and Auth token
       public static final String API_KEY = System.getenv("TWILIO_API_KEY");
       public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
       public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

       public static void main(String[] args) {
           Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);

           ChannelsSender.MessagingV2ChannelsSenderConfiguration configuration =
               new ChannelsSender.MessagingV2ChannelsSenderConfiguration();
           configuration.setVerificationCode("123456");

           ChannelsSender.MessagingV2ChannelsSenderRequestsUpdate messagingV2ChannelsSenderRequestsUpdate =
               new ChannelsSender.MessagingV2ChannelsSenderRequestsUpdate();
           messagingV2ChannelsSenderRequestsUpdate.setConfiguration(messagingV2ChannelsSenderConfiguration);

           ChannelsSender channelsSender =
               ChannelsSender.updater("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", messagingV2ChannelsSenderRequestsUpdate)
                   .update();

           System.out.println(channelsSender.getSid());
       }
   }
   ```

   ```go
   // Download the helper library from https://www.twilio.com/docs/go/install
   package main

   import (
   	"fmt"
   	"github.com/twilio/twilio-go"
   	messaging "github.com/twilio/twilio-go/rest/messaging/v2"
   	"os"
   )

   func ptrOf[T any](v T) *T { return &v }

   func main() {
   	// Find your Account SID at twilio.com/console
   	// Provision API Keys at twilio.com/console/runtime/api-keys
   	// and set the environment variables. See http://twil.io/secure
   	// For local testing, you can use your Account SID and Auth token
   	accountSid := os.Getenv("TWILIO_ACCOUNT_SID")
   	apiKey := os.Getenv("TWILIO_API_KEY")
   	apiSecret := os.Getenv("TWILIO_API_SECRET")
   	client := twilio.NewRestClientWithParams(twilio.ClientParams{
   		Username:   apiKey,
   		Password:   apiSecret,
   		AccountSid: accountSid,
   	})

   	params := &messaging.UpdateChannelsSenderParams{}
   	params.SetMessagingV2ChannelsSenderRequestsUpdate(messaging.MessagingV2ChannelsSenderRequestsUpdate{
   		Configuration: &messaging.MessagingV2ChannelsSenderConfiguration{
   			VerificationCode: ptrOf("123456"),
   		},
   	})

   	resp, err := client.MessagingV2.UpdateChannelsSender("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
   		params)
   	if err != nil {
   		fmt.Println(err.Error())
   		os.Exit(1)
   	} else {
   		if resp.Sid != nil {
   			fmt.Println(*resp.Sid)
   		} else {
   			fmt.Println(resp.Sid)
   		}
   	}
   }
   ```

   ```php
   <?php

   // Update the path below to your autoload.php,
   // see https://getcomposer.org/doc/01-basic-usage.md
   require_once "/path/to/vendor/autoload.php";

   use Twilio\Rest\Client;
   use Twilio\Rest\Messaging\V2\ChannelsSenderModels;

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   $apiKey = $_ENV["TWILIO_API_KEY"];
   $apiSecret = $_ENV["TWILIO_API_SECRET"];
   $sid = $_ENV["TWILIO_ACCOUNT_SID"];
   $twilio = new Client($apiKey, $apiSecret, $sid);

   $channels_sender = $twilio->messaging->v2
       ->channelsSenders("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
       ->update(
           ChannelsSenderModels::createMessagingV2ChannelsSenderRequestsUpdate([
               "configuration" => ChannelsSenderModels::createMessagingV2ChannelsSenderConfiguration(
                   [
                       "verificationCode" => "123456",
                   ],
               ),
           ]),
       );

   print $channels_sender->sid;
   ```

   ```ruby
   # Download the helper library from https://www.twilio.com/docs/ruby/install
   require 'twilio-ruby'

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = ENV['TWILIO_API_KEY']
   api_secret = ENV['TWILIO_API_SECRET']
   account_sid = ENV['TWILIO_ACCOUNT_SID']
   @client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

   channels_sender = @client
                     .messaging
                     .v2
                     .channels_senders('XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                     .update(
                       messaging_v2_channels_sender_requests_update: {
                         'configuration' => {
                           'verification_code' => '123456'
                         }
                       }
                     )

   puts channels_sender.sid
   ```

   ```bash
   # This endpoint is not currently supported by the Twilio CLI. You can open an issue to request it on https://github.com/twilio/twilio-cli/issues
     # For an alternative low-code solution, check out https://www.twilio.com/docs/openapi/using-twilio-postman-collections
   ```

   ```bash
   MESSAGING_V2_CHANNELS_SENDER_REQUESTS_UPDATE_OBJ=$(cat << EOF
   {
     "configuration": {
       "verification_code": "123456"
     }
   }
   EOF
   )
   curl -X POST "https://messaging.twilio.com/v2/Channels/Senders/XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
   --json "$MESSAGING_V2_CHANNELS_SENDER_REQUESTS_UPDATE_OBJ" \
   -u $TWILIO_API_KEY:$TWILIO_API_SECRET
   ```

   ```json
   {
     "sid": "XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
     "status": "VERIFYING",
     "sender_id": "whatsapp:+999999999XX",
     "friendly_name": null,
     "compliance": null,
     "configuration": {
       "verification_code": "123456"
     },
     "webhook": {
       "callback_url": "https://callback.example.com",
       "callback_method": "POST",
       "fallback_url": "https://fallback.example.com",
       "fallback_method": "POST",
       "status_callback_url": "https://statuscallback.example.com",
       "status_callback_method": "POST"
     },
     "profile": {
       "about": "Example about text",
       "address": "123 Example St, Example City, EX 12345",
       "description": "Example description",
       "emails": [
         {
           "email": "email@email.com",
           "label": "Email"
         }
       ],
       "name": "Example Business",
       "logo_url": "https://logo_url.example.com",
       "vertical": "Automotive",
       "websites": [
         {
           "website": "https://website1.example.com",
           "label": "Website"
         },
         {
           "website": "http://website2.example.com",
           "label": "Website"
         }
       ],
       "banner_url": null,
       "privacy_url": null,
       "terms_of_service_url": null,
       "accent_color": null,
       "phone_numbers": null
     },
     "display_name_status": "updating"
   }
   ```
4. To confirm the WhatsApp sender is registered, make a `GET v2/Channels/Senders/{Sid}` request and check if `status` is `ONLINE`.\
   **Note**: Immediately after registration, the `status` value will be `OFFLINE`. Wait a few minutes, then make the request again.

   Confirm WhatsApp sender registration

   ```js
   // Download the helper library from https://www.twilio.com/docs/node/install
   const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   const accountSid = process.env.TWILIO_ACCOUNT_SID;
   const apiKey = process.env.TWILIO_API_KEY;
   const apiSecret = process.env.TWILIO_API_SECRET;
   const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

   async function fetchChannelsSender() {
     const channelsSender = await client.messaging.v2
       .channelsSenders("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
       .fetch();

     console.log(channelsSender.sid);
   }

   fetchChannelsSender();
   ```

   ```python
   # Download the helper library from https://www.twilio.com/docs/python/install
   import os
   from twilio.rest import Client

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = os.environ["TWILIO_API_KEY"]
   api_secret = os.environ["TWILIO_API_SECRET"]
   account_sid = os.environ["TWILIO_ACCOUNT_SID"]
   client = Client(api_key, api_secret, account_sid)

   channels_sender = client.messaging.v2.channels_senders(
       "XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
   ).fetch()

   print(channels_sender.sid)
   ```

   ```csharp
   // Install the C# / .NET helper library from twilio.com/docs/csharp/install

   using System;
   using Twilio;
   using Twilio.Rest.Messaging.V2;
   using System.Threading.Tasks;

   class Program {
       public static async Task Main(string[] args) {
           // Find your Account SID at twilio.com/console
           // Provision API Keys at twilio.com/console/runtime/api-keys
           // and set the environment variables. See http://twil.io/secure
           // For local testing, you can use your Account SID and Auth token
           string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
           string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
           string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

           TwilioClient.Init(apiKey, apiSecret, accountSid);

           var channelsSender =
               await ChannelsSenderResource.FetchAsync(pathSid: "XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");

           Console.WriteLine(channelsSender.Sid);
       }
   }
   ```

   ```java
   // Install the Java helper library from twilio.com/docs/java/install

   import com.twilio.Twilio;
   import com.twilio.rest.messaging.v2.ChannelsSender;

   public class Example {
       // Find your Account SID at twilio.com/console
       // Provision API Keys at twilio.com/console/runtime/api-keys
       // and set the environment variables. See http://twil.io/secure
       // For local testing, you can use your Account SID and Auth token
       public static final String API_KEY = System.getenv("TWILIO_API_KEY");
       public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
       public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

       public static void main(String[] args) {
           Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);
           ChannelsSender channelsSender = ChannelsSender.fetcher("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX").fetch();

           System.out.println(channelsSender.getSid());
       }
   }
   ```

   ```go
   // Download the helper library from https://www.twilio.com/docs/go/install
   package main

   import (
   	"fmt"
   	"github.com/twilio/twilio-go"
   	"os"
   )

   func main() {
   	// Find your Account SID at twilio.com/console
   	// Provision API Keys at twilio.com/console/runtime/api-keys
   	// and set the environment variables. See http://twil.io/secure
   	// For local testing, you can use your Account SID and Auth token
   	accountSid := os.Getenv("TWILIO_ACCOUNT_SID")
   	apiKey := os.Getenv("TWILIO_API_KEY")
   	apiSecret := os.Getenv("TWILIO_API_SECRET")
   	client := twilio.NewRestClientWithParams(twilio.ClientParams{
   		Username:   apiKey,
   		Password:   apiSecret,
   		AccountSid: accountSid,
   	})

   	resp, err := client.MessagingV2.FetchChannelsSender("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
   	if err != nil {
   		fmt.Println(err.Error())
   		os.Exit(1)
   	} else {
   		if resp.Sid != nil {
   			fmt.Println(*resp.Sid)
   		} else {
   			fmt.Println(resp.Sid)
   		}
   	}
   }
   ```

   ```php
   <?php

   // Update the path below to your autoload.php,
   // see https://getcomposer.org/doc/01-basic-usage.md
   require_once "/path/to/vendor/autoload.php";

   use Twilio\Rest\Client;

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   $apiKey = $_ENV["TWILIO_API_KEY"];
   $apiSecret = $_ENV["TWILIO_API_SECRET"];
   $sid = $_ENV["TWILIO_ACCOUNT_SID"];
   $twilio = new Client($apiKey, $apiSecret, $sid);

   $channels_sender = $twilio->messaging->v2
       ->channelsSenders("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
       ->fetch();

   print $channels_sender->sid;
   ```

   ```ruby
   # Download the helper library from https://www.twilio.com/docs/ruby/install
   require 'twilio-ruby'

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = ENV['TWILIO_API_KEY']
   api_secret = ENV['TWILIO_API_SECRET']
   account_sid = ENV['TWILIO_ACCOUNT_SID']
   @client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

   channels_sender = @client
                     .messaging
                     .v2
                     .channels_senders('XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                     .fetch

   puts channels_sender.sid
   ```

   ```bash
   # Install the twilio-cli from https://twil.io/cli

   twilio api:messaging:v2:channels:senders:fetch \
      --sid XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   ```

   ```bash
   curl -X GET "https://messaging.twilio.com/v2/Channels/Senders/XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
   -u $TWILIO_API_KEY:$TWILIO_API_SECRET
   ```

   ```json
   {
     "sid": "XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
     "status": "ONLINE",
     "sender_id": "whatsapp:+999999999XX",
     "configuration": {
       "waba_id": "1234567XXX",
       "verification_method": null,
       "verification_code": null,
       "voice_application_sid": "APXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
       "account_type": null
     },
     "webhook": {
       "callback_url": "https://callback.example.com",
       "callback_method": "POST",
       "fallback_url": "https://fallback.example.com",
       "fallback_method": "POST",
       "status_callback_url": "https://statuscallback.example.com",
       "status_callback_method": "POST"
     },
     "profile": {
       "name": "Example Profile Name",
       "about": "This is an example about text.",
       "address": "123 Example St, Example City, EX 12345",
       "description": "This is an example description.",
       "emails": [
         {
           "email": "email@email.com",
           "label": "Email"
         }
       ],
       "logo_url": "https://logo_url.example.com",
       "vertical": "Automotive",
       "websites": [
         {
           "website": "https://website1.example.com",
           "label": "Website"
         },
         {
           "website": "http://website2.example.com",
           "label": "Website"
         }
       ],
       "banner_url": null,
       "privacy_url": null,
       "terms_of_service_url": null,
       "accent_color": null,
       "use_case": null,
       "phone_numbers": null
     },
     "compliance": null,
     "properties": {
       "quality_rating": "HIGH",
       "messaging_limit": "10K Customers/24hr"
     },
     "offline_reasons": null,
     "url": "https://messaging.twilio.com/v2/Channels/Senders/XEaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
   }
   ```

## Voice: Non-Twilio phone number

1. Make sure your phone number meets all [requirements](#phone-number-requirements) and is able to receive voice calls.
2. To register a WhatsApp sender, make a `POST /v2/Channels/Senders` request. The following properties are required in the request body:

   * `sender_id`: The phone number to register as a WhatsApp sender in [E.164 format](/docs/glossary/what-e164)
   * `profile.name`: The [WhatsApp sender display name](#display-name-requirements)

   For additional properties, see the [Senders API documentation](/docs/whatsapp/api/senders).

   > \[!WARNING]
   >
   > Allow several minutes between Senders API requests. Too many requests in a short period might result in errors.

   Register a WhatsApp sender (Voice: Non-Twilio phone number)

   ```js
   // Download the helper library from https://www.twilio.com/docs/node/install
   const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   const accountSid = process.env.TWILIO_ACCOUNT_SID;
   const apiKey = process.env.TWILIO_API_KEY;
   const apiSecret = process.env.TWILIO_API_SECRET;
   const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

   async function createChannelsSender() {
     const channelsSender = await client.messaging.v2.channelsSenders.create({
       sender_id: "whatsapp:+15017122661",
       configuration: {
         verification_method: "voice",
       },
       webhook: {
         callback_url: "https://demo.twilio.com/welcome/sms/reply/",
         callback_method: "POST",
       },
       profile: {
         name: "Twilio",
         about: "Hello! We are Twilio.",
         address: "101 Spear Street, San Francisco, CA",
         description: "We're excited to see what you build!",
         logo_url: "https://www.twilio.com/logo.png",
         vertical: "Other",
         websites: ["https://twilio.com", "https://help.twilio.com"],
         emails: ["support@twilio.com"],
       },
     });

     console.log(channelsSender.sid);
   }

   createChannelsSender();
   ```

   ```python
   # Download the helper library from https://www.twilio.com/docs/python/install
   import os
   from twilio.rest import Client
   from twilio.rest.messaging.v2 import ChannelsSenderList

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = os.environ["TWILIO_API_KEY"]
   api_secret = os.environ["TWILIO_API_SECRET"]
   account_sid = os.environ["TWILIO_ACCOUNT_SID"]
   client = Client(api_key, api_secret, account_sid)

   channels_sender = client.messaging.v2.channels_senders.create(
       messaging_v2_channels_sender_requests_create=ChannelsSenderList.MessagingV2ChannelsSenderRequestsCreate(
           {
               "sender_id": "whatsapp:+15017122661",
               "configuration": ChannelsSenderList.MessagingV2ChannelsSenderConfiguration(
                   {"verification_method": "voice"}
               ),
               "webhook": ChannelsSenderList.MessagingV2ChannelsSenderWebhook(
                   {
                       "callback_url": "https://demo.twilio.com/welcome/sms/reply/",
                       "callback_method": "POST",
                   }
               ),
               "profile": ChannelsSenderList.MessagingV2ChannelsSenderProfile(
                   {
                       "name": "Twilio",
                       "about": "Hello! We are Twilio.",
                       "address": "101 Spear Street, San Francisco, CA",
                       "description": "We're excited to see what you build!",
                       "logo_url": "https://www.twilio.com/logo.png",
                       "vertical": "Other",
                       "websites": [
                           "https://twilio.com",
                           "https://help.twilio.com",
                       ],
                       "emails": ["support@twilio.com"],
                   }
               ),
           }
       )
   )

   print(channels_sender.sid)
   ```

   ```csharp
   // Install the C# / .NET helper library from twilio.com/docs/csharp/install

   using System;
   using Twilio;
   using Twilio.Rest.Messaging.V2;
   using System.Threading.Tasks;
   using System.Collections.Generic;

   class Program {
       public static async Task Main(string[] args) {
           // Find your Account SID at twilio.com/console
           // Provision API Keys at twilio.com/console/runtime/api-keys
           // and set the environment variables. See http://twil.io/secure
           // For local testing, you can use your Account SID and Auth token
           string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
           string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
           string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

           TwilioClient.Init(apiKey, apiSecret, accountSid);

           var channelsSender = await ChannelsSenderResource.CreateAsync(
               messagingV2ChannelsSenderRequestsCreate: new ChannelsSenderResource
                   .MessagingV2ChannelsSenderRequestsCreate.Builder()
                   .WithSenderId("whatsapp:+15017122661")
                   .WithConfiguration(
                       new ChannelsSenderResource.MessagingV2ChannelsSenderConfiguration.Builder()
                           .WithVerificationMethod("voice")
                           .Build())
                   .WithWebhook(new ChannelsSenderResource.MessagingV2ChannelsSenderWebhook.Builder()
                                    .WithCallbackUrl("https://demo.twilio.com/welcome/sms/reply/")
                                    .WithCallbackMethod("POST")
                                    .Build())
                   .WithProfile(
                       new ChannelsSenderResource.MessagingV2ChannelsSenderProfile.Builder()
                           .WithName("Twilio")
                           .WithAbout("Hello! We are Twilio.")
                           .WithAddress("101 Spear Street, San Francisco, CA")
                           .WithDescription("We're excited to see what you build!")
                           .WithLogoUrl("https://www.twilio.com/logo.png")
                           .WithVertical("Other")
                           .WithWebsites(
                               new List<string> { "https://twilio.com", "https://help.twilio.com" })
                           .WithEmails(new List<string> { "support@twilio.com" })
                           .Build())
                   .Build());

           Console.WriteLine(channelsSender.Sid);
       }
   }
   ```

   ```java
   // Install the Java helper library from twilio.com/docs/java/install

   import java.util.Arrays;
   import java.util.HashMap;
   import com.twilio.Twilio;
   import com.twilio.rest.messaging.v2.ChannelsSender;

   public class Example {
       // Find your Account SID at twilio.com/console
       // Provision API Keys at twilio.com/console/runtime/api-keys
       // and set the environment variables. See http://twil.io/secure
       // For local testing, you can use your Account SID and Auth token
       public static final String API_KEY = System.getenv("TWILIO_API_KEY");
       public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
       public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

       public static void main(String[] args) {
           Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);

           ChannelsSender.MessagingV2ChannelsSenderConfiguration configuration =
               new ChannelsSender.MessagingV2ChannelsSenderConfiguration();
           configuration.setVerificationMethod("voice");

           ChannelsSender.MessagingV2ChannelsSenderWebhook webhook = new ChannelsSender.MessagingV2ChannelsSenderWebhook();
           webhook.setCallbackUrl("https://demo.twilio.com/welcome/sms/reply/");
           webhook.setCallbackMethod("POST");

           ChannelsSender.MessagingV2ChannelsSenderProfile profile = new ChannelsSender.MessagingV2ChannelsSenderProfile();
           profile.setName("Twilio");
           profile.setAbout("Hello! We are Twilio.");
           profile.setAddress("101 Spear Street, San Francisco, CA");
           profile.setDescription("We're excited to see what you build!");
           profile.setLogoUrl("https://www.twilio.com/logo.png");
           profile.setVertical("Other");
           profile.setWebsites(Arrays.asList("https://twilio.com", "https://help.twilio.com"));
           profile.setEmails(Arrays.asList("support@twilio.com"));

           ChannelsSender.MessagingV2ChannelsSenderRequestsCreate messagingV2ChannelsSenderRequestsCreate =
               new ChannelsSender.MessagingV2ChannelsSenderRequestsCreate();
           messagingV2ChannelsSenderRequestsCreate.setSenderId("whatsapp:+15017122661");
           messagingV2ChannelsSenderRequestsCreate.setConfiguration(messagingV2ChannelsSenderConfiguration);
           messagingV2ChannelsSenderRequestsCreate.setWebhook(messagingV2ChannelsSenderWebhook);
           messagingV2ChannelsSenderRequestsCreate.setProfile(messagingV2ChannelsSenderProfile);

           ChannelsSender channelsSender = ChannelsSender.creator(messagingV2ChannelsSenderRequestsCreate).create();

           System.out.println(channelsSender.getSid());
       }
   }
   ```

   ```go
   // Download the helper library from https://www.twilio.com/docs/go/install
   package main

   import (
   	"fmt"
   	"github.com/twilio/twilio-go"
   	messaging "github.com/twilio/twilio-go/rest/messaging/v2"
   	"os"
   )

   func ptrOf[T any](v T) *T { return &v }

   func main() {
   	// Find your Account SID at twilio.com/console
   	// Provision API Keys at twilio.com/console/runtime/api-keys
   	// and set the environment variables. See http://twil.io/secure
   	// For local testing, you can use your Account SID and Auth token
   	accountSid := os.Getenv("TWILIO_ACCOUNT_SID")
   	apiKey := os.Getenv("TWILIO_API_KEY")
   	apiSecret := os.Getenv("TWILIO_API_SECRET")
   	client := twilio.NewRestClientWithParams(twilio.ClientParams{
   		Username:   apiKey,
   		Password:   apiSecret,
   		AccountSid: accountSid,
   	})

   	params := &messaging.CreateChannelsSenderParams{}
   	params.SetMessagingV2ChannelsSenderRequestsCreate(messaging.MessagingV2ChannelsSenderRequestsCreate{
   		SenderId: ptrOf("whatsapp:+15017122661"),
   		Configuration: &messaging.MessagingV2ChannelsSenderConfiguration{
   			VerificationMethod: ptrOf("voice"),
   		},
   		Webhook: &messaging.MessagingV2ChannelsSenderWebhook{
   			CallbackUrl:    ptrOf("https://demo.twilio.com/welcome/sms/reply/"),
   			CallbackMethod: ptrOf("POST"),
   		},
   		Profile: &messaging.MessagingV2ChannelsSenderProfile{
   			Name:        ptrOf("Twilio"),
   			About:       ptrOf("Hello! We are Twilio."),
   			Address:     ptrOf("101 Spear Street, San Francisco, CA"),
   			Description: ptrOf("We're excited to see what you build!"),
   			LogoUrl:     ptrOf("https://www.twilio.com/logo.png"),
   			Vertical:    ptrOf("Other"),
   			Websites: []string{
   				"https://twilio.com",
   				"https://help.twilio.com",
   			},
   			Emails: []string{
   				"support@twilio.com",
   			},
   		},
   	})

   	resp, err := client.MessagingV2.CreateChannelsSender(params)
   	if err != nil {
   		fmt.Println(err.Error())
   		os.Exit(1)
   	} else {
   		if resp.Sid != nil {
   			fmt.Println(*resp.Sid)
   		} else {
   			fmt.Println(resp.Sid)
   		}
   	}
   }
   ```

   ```php
   <?php

   // Update the path below to your autoload.php,
   // see https://getcomposer.org/doc/01-basic-usage.md
   require_once "/path/to/vendor/autoload.php";

   use Twilio\Rest\Client;
   use Twilio\Rest\Messaging\V2\ChannelsSenderModels;

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   $apiKey = $_ENV["TWILIO_API_KEY"];
   $apiSecret = $_ENV["TWILIO_API_SECRET"];
   $sid = $_ENV["TWILIO_ACCOUNT_SID"];
   $twilio = new Client($apiKey, $apiSecret, $sid);

   $channels_sender = $twilio->messaging->v2->channelsSenders->create(
       ChannelsSenderModels::createMessagingV2ChannelsSenderRequestsCreate([
           "senderId" => "whatsapp:+15017122661",
           "configuration" => ChannelsSenderModels::createMessagingV2ChannelsSenderConfiguration(
               [
                   "verificationMethod" => "voice",
               ],
           ),
           "webhook" => ChannelsSenderModels::createMessagingV2ChannelsSenderWebhook(
               [
                   "callbackUrl" => "https://demo.twilio.com/welcome/sms/reply/",
                   "callbackMethod" => "POST",
               ],
           ),
           "profile" => ChannelsSenderModels::createMessagingV2ChannelsSenderProfile(
               [
                   "name" => "Twilio",
                   "about" => "Hello! We are Twilio.",
                   "address" => "101 Spear Street, San Francisco, CA",
                   "description" => "We're excited to see what you build!",
                   "logoUrl" => "https://www.twilio.com/logo.png",
                   "vertical" => "Other",
                   "websites" => ["https://twilio.com", "https://help.twilio.com"],
                   "emails" => ["support@twilio.com"],
               ],
           ),
       ]),
   );

   print $channels_sender->sid;
   ```

   ```ruby
   # Download the helper library from https://www.twilio.com/docs/ruby/install
   require 'twilio-ruby'

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = ENV['TWILIO_API_KEY']
   api_secret = ENV['TWILIO_API_SECRET']
   account_sid = ENV['TWILIO_ACCOUNT_SID']
   @client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

   channels_sender = @client
                     .messaging
                     .v2
                     .channels_senders
                     .create(
                       messaging_v2_channels_sender_requests_create: {
                         'sender_id' => 'whatsapp:+15017122661',
                         'configuration' => {
                           'verification_method' => 'voice'
                         },
                         'webhook' => {
                           'callback_url' => 'https://demo.twilio.com/welcome/sms/reply/',
                           'callback_method' => 'POST'
                         },
                         'profile' => {
                           'name' => 'Twilio',
                           'about' => 'Hello! We are Twilio.',
                           'address' => '101 Spear Street, San Francisco, CA',
                           'description' => 'We\'re excited to see what you build!',
                           'logo_url' => 'https://www.twilio.com/logo.png',
                           'vertical' => 'Other',
                           'websites' => [
                             'https://twilio.com',
                             'https://help.twilio.com'
                           ],
                           'emails' => [
                             'support@twilio.com'
                           ]
                         }
                       }
                     )

   puts channels_sender.sid
   ```

   ```bash
   # This endpoint is not currently supported by the Twilio CLI. You can open an issue to request it on https://github.com/twilio/twilio-cli/issues
     # For an alternative low-code solution, check out https://www.twilio.com/docs/openapi/using-twilio-postman-collections
   ```

   ```bash
   EXCLAMATION_MARK='!'

   MESSAGING_V2_CHANNELS_SENDER_REQUESTS_CREATE_OBJ=$(cat << EOF
   {
     "sender_id": "whatsapp:+15017122661",
     "configuration": {
       "verification_method": "voice"
     },
     "webhook": {
       "callback_url": "https://demo.twilio.com/welcome/sms/reply/",
       "callback_method": "POST"
     },
     "profile": {
       "name": "Twilio",
       "about": "Hello$EXCLAMATION_MARK We are Twilio.",
       "address": "101 Spear Street, San Francisco, CA",
       "description": "We're excited to see what you build!",
       "logo_url": "https://www.twilio.com/logo.png",
       "vertical": "Other",
       "websites": [
         "https://twilio.com",
         "https://help.twilio.com"
       ],
       "emails": [
         "support@twilio.com"
       ]
     }
   }
   EOF
   )
   curl -X POST "https://messaging.twilio.com/v2/Channels/Senders" \
   --json "$MESSAGING_V2_CHANNELS_SENDER_REQUESTS_CREATE_OBJ" \
   -u $TWILIO_API_KEY:$TWILIO_API_SECRET
   ```

   ```json
   {
     "sid": "XEaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
     "status": "CREATING",
     "sender_id": "whatsapp:+15017122661",
     "configuration": {
       "verification_method": "voice"
     },
     "webhook": {
       "callback_url": "https://demo.twilio.com/welcome/sms/reply/",
       "callback_method": "POST"
     },
     "profile": {
       "name": "Twilio",
       "about": "Hello! We are Twilio.",
       "address": "101 Spear Street, San Francisco, CA",
       "description": "We're excited to see what you build!",
       "logo_url": "https://www.twilio.com/logo.png",
       "vertical": "Other",
       "websites": [
         "https://twilio.com",
         "https://help.twilio.com"
       ],
       "emails": [
         "support@twilio.com"
       ]
     }
   }
   ```

   This request creates a WhatsApp sender in Twilio's system, adds it to the WABA connected to your Twilio account, and triggers the OTP from Meta.
3. To verify the phone number, make a `POST /v2/Channels/Senders/{Sid}` request with the OTP received via a voice call.

   Verify the phone number

   ```js
   // Download the helper library from https://www.twilio.com/docs/node/install
   const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   const accountSid = process.env.TWILIO_ACCOUNT_SID;
   const apiKey = process.env.TWILIO_API_KEY;
   const apiSecret = process.env.TWILIO_API_SECRET;
   const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

   async function updateChannelsSender() {
     const channelsSender = await client.messaging.v2
       .channelsSenders("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
       .update({
         configuration: {
           verification_code: "123456",
         },
       });

     console.log(channelsSender.sid);
   }

   updateChannelsSender();
   ```

   ```python
   # Download the helper library from https://www.twilio.com/docs/python/install
   import os
   from twilio.rest import Client
   from twilio.rest.messaging.v2 import ChannelsSenderList

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = os.environ["TWILIO_API_KEY"]
   api_secret = os.environ["TWILIO_API_SECRET"]
   account_sid = os.environ["TWILIO_ACCOUNT_SID"]
   client = Client(api_key, api_secret, account_sid)

   channels_sender = client.messaging.v2.channels_senders(
       "XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
   ).update(
       messaging_v2_channels_sender_requests_update=ChannelsSenderList.MessagingV2ChannelsSenderRequestsUpdate(
           {
               "configuration": ChannelsSenderList.MessagingV2ChannelsSenderConfiguration(
                   {"verification_code": "123456"}
               )
           }
       )
   )

   print(channels_sender.sid)
   ```

   ```csharp
   // Install the C# / .NET helper library from twilio.com/docs/csharp/install

   using System;
   using Twilio;
   using Twilio.Rest.Messaging.V2;
   using System.Threading.Tasks;
   using System.Collections.Generic;

   class Program {
       public static async Task Main(string[] args) {
           // Find your Account SID at twilio.com/console
           // Provision API Keys at twilio.com/console/runtime/api-keys
           // and set the environment variables. See http://twil.io/secure
           // For local testing, you can use your Account SID and Auth token
           string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
           string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
           string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

           TwilioClient.Init(apiKey, apiSecret, accountSid);

           var channelsSender = await ChannelsSenderResource.UpdateAsync(
               new UpdateChannelsSenderOptions("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") {
                   MessagingV2ChannelsSenderRequestsUpdate =
                       new ChannelsSenderResource.MessagingV2ChannelsSenderRequestsUpdate.Builder()
                           .WithConfiguration(
                               new ChannelsSenderResource.MessagingV2ChannelsSenderConfiguration
                                   .Builder()
                                   .WithVerificationCode("123456")
                                   .Build())
                           .Build()
               });

           Console.WriteLine(channelsSender.Sid);
       }
   }
   ```

   ```java
   // Install the Java helper library from twilio.com/docs/java/install

   import java.util.Arrays;
   import java.util.HashMap;
   import com.twilio.Twilio;
   import com.twilio.rest.messaging.v2.ChannelsSender;

   public class Example {
       // Find your Account SID at twilio.com/console
       // Provision API Keys at twilio.com/console/runtime/api-keys
       // and set the environment variables. See http://twil.io/secure
       // For local testing, you can use your Account SID and Auth token
       public static final String API_KEY = System.getenv("TWILIO_API_KEY");
       public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
       public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

       public static void main(String[] args) {
           Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);

           ChannelsSender.MessagingV2ChannelsSenderConfiguration configuration =
               new ChannelsSender.MessagingV2ChannelsSenderConfiguration();
           configuration.setVerificationCode("123456");

           ChannelsSender.MessagingV2ChannelsSenderRequestsUpdate messagingV2ChannelsSenderRequestsUpdate =
               new ChannelsSender.MessagingV2ChannelsSenderRequestsUpdate();
           messagingV2ChannelsSenderRequestsUpdate.setConfiguration(messagingV2ChannelsSenderConfiguration);

           ChannelsSender channelsSender =
               ChannelsSender.updater("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", messagingV2ChannelsSenderRequestsUpdate)
                   .update();

           System.out.println(channelsSender.getSid());
       }
   }
   ```

   ```go
   // Download the helper library from https://www.twilio.com/docs/go/install
   package main

   import (
   	"fmt"
   	"github.com/twilio/twilio-go"
   	messaging "github.com/twilio/twilio-go/rest/messaging/v2"
   	"os"
   )

   func ptrOf[T any](v T) *T { return &v }

   func main() {
   	// Find your Account SID at twilio.com/console
   	// Provision API Keys at twilio.com/console/runtime/api-keys
   	// and set the environment variables. See http://twil.io/secure
   	// For local testing, you can use your Account SID and Auth token
   	accountSid := os.Getenv("TWILIO_ACCOUNT_SID")
   	apiKey := os.Getenv("TWILIO_API_KEY")
   	apiSecret := os.Getenv("TWILIO_API_SECRET")
   	client := twilio.NewRestClientWithParams(twilio.ClientParams{
   		Username:   apiKey,
   		Password:   apiSecret,
   		AccountSid: accountSid,
   	})

   	params := &messaging.UpdateChannelsSenderParams{}
   	params.SetMessagingV2ChannelsSenderRequestsUpdate(messaging.MessagingV2ChannelsSenderRequestsUpdate{
   		Configuration: &messaging.MessagingV2ChannelsSenderConfiguration{
   			VerificationCode: ptrOf("123456"),
   		},
   	})

   	resp, err := client.MessagingV2.UpdateChannelsSender("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
   		params)
   	if err != nil {
   		fmt.Println(err.Error())
   		os.Exit(1)
   	} else {
   		if resp.Sid != nil {
   			fmt.Println(*resp.Sid)
   		} else {
   			fmt.Println(resp.Sid)
   		}
   	}
   }
   ```

   ```php
   <?php

   // Update the path below to your autoload.php,
   // see https://getcomposer.org/doc/01-basic-usage.md
   require_once "/path/to/vendor/autoload.php";

   use Twilio\Rest\Client;
   use Twilio\Rest\Messaging\V2\ChannelsSenderModels;

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   $apiKey = $_ENV["TWILIO_API_KEY"];
   $apiSecret = $_ENV["TWILIO_API_SECRET"];
   $sid = $_ENV["TWILIO_ACCOUNT_SID"];
   $twilio = new Client($apiKey, $apiSecret, $sid);

   $channels_sender = $twilio->messaging->v2
       ->channelsSenders("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
       ->update(
           ChannelsSenderModels::createMessagingV2ChannelsSenderRequestsUpdate([
               "configuration" => ChannelsSenderModels::createMessagingV2ChannelsSenderConfiguration(
                   [
                       "verificationCode" => "123456",
                   ],
               ),
           ]),
       );

   print $channels_sender->sid;
   ```

   ```ruby
   # Download the helper library from https://www.twilio.com/docs/ruby/install
   require 'twilio-ruby'

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = ENV['TWILIO_API_KEY']
   api_secret = ENV['TWILIO_API_SECRET']
   account_sid = ENV['TWILIO_ACCOUNT_SID']
   @client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

   channels_sender = @client
                     .messaging
                     .v2
                     .channels_senders('XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                     .update(
                       messaging_v2_channels_sender_requests_update: {
                         'configuration' => {
                           'verification_code' => '123456'
                         }
                       }
                     )

   puts channels_sender.sid
   ```

   ```bash
   # This endpoint is not currently supported by the Twilio CLI. You can open an issue to request it on https://github.com/twilio/twilio-cli/issues
     # For an alternative low-code solution, check out https://www.twilio.com/docs/openapi/using-twilio-postman-collections
   ```

   ```bash
   MESSAGING_V2_CHANNELS_SENDER_REQUESTS_UPDATE_OBJ=$(cat << EOF
   {
     "configuration": {
       "verification_code": "123456"
     }
   }
   EOF
   )
   curl -X POST "https://messaging.twilio.com/v2/Channels/Senders/XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
   --json "$MESSAGING_V2_CHANNELS_SENDER_REQUESTS_UPDATE_OBJ" \
   -u $TWILIO_API_KEY:$TWILIO_API_SECRET
   ```

   ```json
   {
     "sid": "XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
     "status": "VERIFYING",
     "sender_id": "whatsapp:+999999999XX",
     "friendly_name": null,
     "compliance": null,
     "configuration": {
       "verification_code": "123456"
     },
     "webhook": {
       "callback_url": "https://callback.example.com",
       "callback_method": "POST",
       "fallback_url": "https://fallback.example.com",
       "fallback_method": "POST",
       "status_callback_url": "https://statuscallback.example.com",
       "status_callback_method": "POST"
     },
     "profile": {
       "about": "Example about text",
       "address": "123 Example St, Example City, EX 12345",
       "description": "Example description",
       "emails": [
         {
           "email": "email@email.com",
           "label": "Email"
         }
       ],
       "name": "Example Business",
       "logo_url": "https://logo_url.example.com",
       "vertical": "Automotive",
       "websites": [
         {
           "website": "https://website1.example.com",
           "label": "Website"
         },
         {
           "website": "http://website2.example.com",
           "label": "Website"
         }
       ],
       "banner_url": null,
       "privacy_url": null,
       "terms_of_service_url": null,
       "accent_color": null,
       "phone_numbers": null
     },
     "display_name_status": "updating"
   }
   ```
4. To confirm the WhatsApp sender is registered, make a `GET v2/Channels/Senders/{Sid}` request and check if `status` is `ONLINE`.\
   **Note**: Immediately after registration, the `status` value will be `OFFLINE`. Wait a few minutes, then make the request again.

   Confirm WhatsApp sender registration

   ```js
   // Download the helper library from https://www.twilio.com/docs/node/install
   const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   const accountSid = process.env.TWILIO_ACCOUNT_SID;
   const apiKey = process.env.TWILIO_API_KEY;
   const apiSecret = process.env.TWILIO_API_SECRET;
   const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

   async function fetchChannelsSender() {
     const channelsSender = await client.messaging.v2
       .channelsSenders("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
       .fetch();

     console.log(channelsSender.sid);
   }

   fetchChannelsSender();
   ```

   ```python
   # Download the helper library from https://www.twilio.com/docs/python/install
   import os
   from twilio.rest import Client

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = os.environ["TWILIO_API_KEY"]
   api_secret = os.environ["TWILIO_API_SECRET"]
   account_sid = os.environ["TWILIO_ACCOUNT_SID"]
   client = Client(api_key, api_secret, account_sid)

   channels_sender = client.messaging.v2.channels_senders(
       "XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
   ).fetch()

   print(channels_sender.sid)
   ```

   ```csharp
   // Install the C# / .NET helper library from twilio.com/docs/csharp/install

   using System;
   using Twilio;
   using Twilio.Rest.Messaging.V2;
   using System.Threading.Tasks;

   class Program {
       public static async Task Main(string[] args) {
           // Find your Account SID at twilio.com/console
           // Provision API Keys at twilio.com/console/runtime/api-keys
           // and set the environment variables. See http://twil.io/secure
           // For local testing, you can use your Account SID and Auth token
           string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
           string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
           string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

           TwilioClient.Init(apiKey, apiSecret, accountSid);

           var channelsSender =
               await ChannelsSenderResource.FetchAsync(pathSid: "XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");

           Console.WriteLine(channelsSender.Sid);
       }
   }
   ```

   ```java
   // Install the Java helper library from twilio.com/docs/java/install

   import com.twilio.Twilio;
   import com.twilio.rest.messaging.v2.ChannelsSender;

   public class Example {
       // Find your Account SID at twilio.com/console
       // Provision API Keys at twilio.com/console/runtime/api-keys
       // and set the environment variables. See http://twil.io/secure
       // For local testing, you can use your Account SID and Auth token
       public static final String API_KEY = System.getenv("TWILIO_API_KEY");
       public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
       public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

       public static void main(String[] args) {
           Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);
           ChannelsSender channelsSender = ChannelsSender.fetcher("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX").fetch();

           System.out.println(channelsSender.getSid());
       }
   }
   ```

   ```go
   // Download the helper library from https://www.twilio.com/docs/go/install
   package main

   import (
   	"fmt"
   	"github.com/twilio/twilio-go"
   	"os"
   )

   func main() {
   	// Find your Account SID at twilio.com/console
   	// Provision API Keys at twilio.com/console/runtime/api-keys
   	// and set the environment variables. See http://twil.io/secure
   	// For local testing, you can use your Account SID and Auth token
   	accountSid := os.Getenv("TWILIO_ACCOUNT_SID")
   	apiKey := os.Getenv("TWILIO_API_KEY")
   	apiSecret := os.Getenv("TWILIO_API_SECRET")
   	client := twilio.NewRestClientWithParams(twilio.ClientParams{
   		Username:   apiKey,
   		Password:   apiSecret,
   		AccountSid: accountSid,
   	})

   	resp, err := client.MessagingV2.FetchChannelsSender("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
   	if err != nil {
   		fmt.Println(err.Error())
   		os.Exit(1)
   	} else {
   		if resp.Sid != nil {
   			fmt.Println(*resp.Sid)
   		} else {
   			fmt.Println(resp.Sid)
   		}
   	}
   }
   ```

   ```php
   <?php

   // Update the path below to your autoload.php,
   // see https://getcomposer.org/doc/01-basic-usage.md
   require_once "/path/to/vendor/autoload.php";

   use Twilio\Rest\Client;

   // Find your Account SID at twilio.com/console
   // Provision API Keys at twilio.com/console/runtime/api-keys
   // and set the environment variables. See http://twil.io/secure
   // For local testing, you can use your Account SID and Auth token
   $apiKey = $_ENV["TWILIO_API_KEY"];
   $apiSecret = $_ENV["TWILIO_API_SECRET"];
   $sid = $_ENV["TWILIO_ACCOUNT_SID"];
   $twilio = new Client($apiKey, $apiSecret, $sid);

   $channels_sender = $twilio->messaging->v2
       ->channelsSenders("XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
       ->fetch();

   print $channels_sender->sid;
   ```

   ```ruby
   # Download the helper library from https://www.twilio.com/docs/ruby/install
   require 'twilio-ruby'

   # Find your Account SID at twilio.com/console
   # Provision API Keys at twilio.com/console/runtime/api-keys
   # and set the environment variables. See http://twil.io/secure
   # For local testing, you can use your Account SID and Auth token
   api_key = ENV['TWILIO_API_KEY']
   api_secret = ENV['TWILIO_API_SECRET']
   account_sid = ENV['TWILIO_ACCOUNT_SID']
   @client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

   channels_sender = @client
                     .messaging
                     .v2
                     .channels_senders('XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                     .fetch

   puts channels_sender.sid
   ```

   ```bash
   # Install the twilio-cli from https://twil.io/cli

   twilio api:messaging:v2:channels:senders:fetch \
      --sid XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   ```

   ```bash
   curl -X GET "https://messaging.twilio.com/v2/Channels/Senders/XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
   -u $TWILIO_API_KEY:$TWILIO_API_SECRET
   ```

   ```json
   {
     "sid": "XEXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
     "status": "ONLINE",
     "sender_id": "whatsapp:+999999999XX",
     "configuration": {
       "waba_id": "1234567XXX",
       "verification_method": null,
       "verification_code": null,
       "voice_application_sid": "APXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
       "account_type": null
     },
     "webhook": {
       "callback_url": "https://callback.example.com",
       "callback_method": "POST",
       "fallback_url": "https://fallback.example.com",
       "fallback_method": "POST",
       "status_callback_url": "https://statuscallback.example.com",
       "status_callback_method": "POST"
     },
     "profile": {
       "name": "Example Profile Name",
       "about": "This is an example about text.",
       "address": "123 Example St, Example City, EX 12345",
       "description": "This is an example description.",
       "emails": [
         {
           "email": "email@email.com",
           "label": "Email"
         }
       ],
       "logo_url": "https://logo_url.example.com",
       "vertical": "Automotive",
       "websites": [
         {
           "website": "https://website1.example.com",
           "label": "Website"
         },
         {
           "website": "http://website2.example.com",
           "label": "Website"
         }
       ],
       "banner_url": null,
       "privacy_url": null,
       "terms_of_service_url": null,
       "accent_color": null,
       "use_case": null,
       "phone_numbers": null
     },
     "compliance": null,
     "properties": {
       "quality_rating": "HIGH",
       "messaging_limit": "10K Customers/24hr"
     },
     "offline_reasons": null,
     "url": "https://messaging.twilio.com/v2/Channels/Senders/XEaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
   }
   ```

## Troubleshooting

The following troubleshooting steps can help you resolve common issues when you register a WhatsApp sender.

### I want to check if a phone number is registered with WhatsApp

To check if a phone number is registered with WhatsApp, use one of the following methods:

* **Send a test message**: Open `https://wa.me/<PHONE_NUMBER>?text=hi` in a browser (include the country code without `+`, for example, `15551234`). If the number is registered, you'll receive "hi" in WhatsApp.
* **Search contacts**: In WhatsApp, tap **New Chat > New Contact** and enter the phone number. If the number is registered, you'll see "This phone number is on WhatsApp".
* **Check error logs**: Open the [Error Logs page in the Twilio Console](https://console.twilio.com/us1/monitor/logs/debugger/errors). If the number is registered, you'll see [Error 63110](/docs/api/errors/63110).

### I want to use an already registered phone number

To use a phone number that's already registered with WhatsApp:

* **If registered with WhatsApp or WhatsApp Business app**: [Delete the WhatsApp account](https://faq.whatsapp.com/2138577903196467) to make the phone number available for the WhatsApp Business Platform with Twilio.
* **If registered with another WhatsApp Business Platform**: In the [WhatsApp Manager](https://business.facebook.com/latest/whatsapp_manager/), turn off Two-Factor Authentication (2FA) for the number on the WhatsApp Business Platform and register a WhatsApp sender with the number. Contact your Solution Partner if you can't turn off 2FA by yourself.

Learn more about [migrating phone numbers and WhatsApp senders](/docs/whatsapp/migrate-numbers-and-senders). If you need further assistance, [contact Twilio Support](https://help.twilio.com/).

### I can't use Argentina or Mexico phone numbers

* **For Argentina phone numbers** (+54): Add a `9` after the country code and remove the prefix `15` (for example, `+549 XXX XXX XXXX`).
* **For Mexico phone numbers** (+52): Add a `1` after the country code (for example, `+521 XX XXXX XXXX`).

Learn more about [WhatsApp's international phone number format](https://faq.whatsapp.com/1294841057948784).

### I'm not receiving an OTP via SMS

You might not receive an OTP via SMS for the following reasons:

* The OTP delivery is delayed.
* You've reached Meta's maximum number of OTP verification attempts.

To resolve this issue:

1. Wait a few minutes.
2. Check the [Error logs](https://console.twilio.com/us1/monitor/logs/debugger/errors) for any errors and follow the recommended actions.
3. Resend an OTP by making another `POST /v2/Channels/Senders` request.
4. If you don't receive the OTP after several attempts, contact [Twilio Support](https://help.twilio.com/).

Alternatively, you can try the voice method for verification.

### The `status` field remains `OFFLINE`

The `status` field briefly shows as `OFFLINE` after registration. The `status` field changes to `ONLINE` when registration is complete, which typically takes a few minutes. If the `status` field remains `OFFLINE` after that, follow these steps:

1. Confirm the phone number meets all [requirements](#phone-number-requirements).
2. Confirm the display name follows [Meta's display name guidelines](https://www.facebook.com/business/help/757569725593362).
3. Check the [Error logs](https://console.twilio.com/us1/monitor/logs/debugger/errors) for any errors and follow the recommended actions.
4. Check your WABA status on [WhatsApp Manager](https://business.facebook.com/latest/whatsapp_manager/).
5. If you still see `OFFLINE`, [contact Twilio Support](https://help.twilio.com/).
