Quickstart: Send and receive WhatsApp messages

• Get a WhatsApp account and install WhatsApp on your device.

• Install Python.

• Install Flask and Twilio's Python helper library. To install using pip, run:

  Copy code block

  pip install flask twilio

• Install and set up ngrok.

• Get a WhatsApp account and install WhatsApp on your device.

• Install Node.js.

• Install Express and the Twilio Node.js helper library:

  Copy code block

  npm install express twilio

• Install and set up ngrok.

• Get a WhatsApp account and install WhatsApp on your device.

• Install PHP.

• Install dependencies with Composer:

  1. Install Composer.

  2. Install the Twilio PHP helper library:

     Copy code block

     1
     composer require twilio/sdk
     2
     composer install

• Install and set up ngrok.

• Get a WhatsApp account and install WhatsApp on your device.
• Download Visual Studio 2019 or later.
• Install and set up ngrok.

• Get a WhatsApp account and install WhatsApp on your device.
• Install Java Standard Edition (SE) Development Kit.
• Download the Twilio Java helper library fat jar file with all dependencies:
  1. Navigate to the Maven repository for the Twilio Java helper library.
  2. Click the most recent version number.
  3. In the Files row, click View All.
  4. Click the file ending in jar-with-dependencies.jar.
  5. Create a project directory for this quickstart and move the fat jar from your downloads into the new project directory.
• Install IntelliJ IDEA Community Edition.
• Install and set up ngrok.

• Get a WhatsApp account and install WhatsApp on your device.
• curl is installed by default on macOS, Windows, and on most Linux distributions. Run curl --version from your terminal to check.

• Get a WhatsApp account and install WhatsApp on your device.
• Install Go.
• Install and set up ngrok.

• Get a WhatsApp account and install WhatsApp on your device.
• Install Ruby.
• Install Sinatra and the Twilio Ruby helper library. Run the following command to create a Gemfile and add and install the gems:
  Copy code block

  bundle init && bundle add sinatra twilio-ruby

• Install and set up ngrok.

1. Go to the Twilio Console.
2. Copy your Account SID and set it as an environment variable using the following command. Replace ACCOUNT_SID with your Account SID.
   Copy code block

   export TWILIO_ACCOUNT_SID=ACCOUNT_SID

3. Copy your Auth Token and set it as an environment variable using the following command. Replace AUTH_TOKEN with your Auth Token.
   Copy code block

   export TWILIO_AUTH_TOKEN=AUTH_TOKEN

1. Go to the Twilio Console.
2. Copy your Account SID and set it as an environment variable using the following command. Replace ACCOUNT_SID with your Account SID.
   Copy code block

   set TWILIO_ACCOUNT_SID=ACCOUNT_SID

3. Copy your Auth Token and set it as an environment variable using the following command. Replace AUTH_TOKEN with your Auth Token.
   Copy code block

   set TWILIO_AUTH_TOKEN=AUTH_TOKEN

1. Go to the Twilio Console.
2. Copy your Account SID and set it as an environment variable using the following command. Replace ACCOUNT_SID with your Account SID.
   Copy code block

   $Env:TWILIO_ACCOUNT_SID="ACCOUNT_SID"

3. Copy your Auth Token and set it as an environment variable using the following command. Replace AUTH_TOKEN with your Auth Token.
   Copy code block

   $Env:TWILIO_AUTH_TOKEN="AUTH_TOKEN"

1. Create and open a new file called send_whatsapp.py anywhere on your machine and paste in the following code:

   Send a message with WhatsApp, Twilio, and Python

   Report code block

   Copy code block

   1
   # Download the helper library from https://www.twilio.com/docs/python/install
   2
   import os
   3
   from twilio.rest import Client
   4
   import json
   5
   
   6
   # Find your Account SID and Auth Token at twilio.com/console
   7
   # and set the environment variables. See http://twil.io/secure
   8
   account_sid = os.environ["TWILIO_ACCOUNT_SID"]
   9
   auth_token = os.environ["TWILIO_AUTH_TOKEN"]
   10
   client = Client(account_sid, auth_token)
   11
   
   12
   message = client.messages.create(
   13
       from_="whatsapp:+14155238886",
   14
       to="whatsapp:+16285550100",
   15
       content_sid="HXb5b62575e6e4ff6129ad7c8efe1f983e",
   16
       content_variables=json.dumps({"1": "22 July 2026", "2": "3:15pm"}),
   17
   )
   18
   
   19
   print(message.body)

2. Replace the value for to with the whatsapp: prefix and your personal WhatsApp number in E.164 format. For example, whatsapp:+16285550100.

3. Save your changes and run this command from your terminal in the directory that contains send_whatsapp.py:

   Copy code block

   python send_whatsapp.py

After a few moments, you receive a WhatsApp message from the Sandbox to your personal WhatsApp account.

1. Create and open a new file called send_whatsapp.js anywhere on your machine and paste in the following code:

   Send a message with WhatsApp, Twilio, and Node.js

   Report code block

   Copy code block

   1
   // Download the helper library from https://www.twilio.com/docs/node/install
   2
   const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";
   3
   
   4
   // Find your Account SID and Auth Token at twilio.com/console
   5
   // and set the environment variables. See http://twil.io/secure
   6
   const accountSid = process.env.TWILIO_ACCOUNT_SID;
   7
   const authToken = process.env.TWILIO_AUTH_TOKEN;
   8
   const client = twilio(accountSid, authToken);
   9
   
   10
   async function createMessage() {
   11
     const message = await client.messages.create({
   12
       contentSid: "HXb5b62575e6e4ff6129ad7c8efe1f983e",
   13
       contentVariables: JSON.stringify({ 1: "22 July 2026", 2: "3:15pm" }),
   14
       from: "whatsapp:+14155238886",
   15
       to: "whatsapp:+16285550100",
   16
     });
   17
   
   18
     console.log(message.body);
   19
   }
   20
   
   21
   createMessage();

2. Replace the value for to with the whatsapp: prefix and your personal WhatsApp number in E.164 format. For example, whatsapp:+16285550100.

3. Save your changes and run the following command from your terminal in the directory that contains send_whatsapp.js:

   Copy code block

   node send_whatsapp.js

After a few moments, you receive a WhatsApp message from the Sandbox to your personal WhatsApp account.

1. Create and open a new file called send_whatsapp.php in the project directory and paste in the following code:

   Send a message with WhatsApp, Twilio, and PHP

   Report code block

   Copy code block

   1
   <?php
   2
   
   3
   // Update the path below to your autoload.php,
   4
   // see https://getcomposer.org/doc/01-basic-usage.md
   5
   require_once "/path/to/vendor/autoload.php";
   6
   
   7
   use Twilio\Rest\Client;
   8
   
   9
   // Find your Account SID and Auth Token at twilio.com/console
   10
   // and set the environment variables. See http://twil.io/secure
   11
   $sid = getenv("TWILIO_ACCOUNT_SID");
   12
   $token = getenv("TWILIO_AUTH_TOKEN");
   13
   $twilio = new Client($sid, $token);
   14
   
   15
   $message = $twilio->messages->create(
   16
       "whatsapp:+16285550100", // To
   17
       [
   18
           "from" => "whatsapp:+14155238886",
   19
           "contentSid" => "HXb5b62575e6e4ff6129ad7c8efe1f983e",
   20
           "contentVariables" => json_encode([
   21
               "1" => "22 July 2026",
   22
               "2" => "3:15pm",
   23
           ]),
   24
       ]
   25
   );
   26
   
   27
   print $message->body;

2. Replace the first argument to $twilio->messages->create() with your personal WhatsApp number in E.164 format, prefixed by whatsapp:. For example, whatsapp:+16285550100.

3. Replace line 5 of send_whatsapp.php with the following:

   Copy code block

   require __DIR__ . '/vendor/autoload.php';

4. Save your changes and run this command from your terminal in the directory that contains send_whatsapp.php:

   Copy code block

   php send_whatsapp.php

After a few moments, you receive a WhatsApp message from the Sandbox to your personal WhatsApp account.

1. Create and set up a new project in Visual Studio:
   1. Open Visual Studio and click Create a new project.
   2. Click Console App (.NET Framework).
   3. Use the NuGet Package Manager to install the Twilio REST API helper library.
2. Open the file in your new Visual Studio project called Program.cs and paste in the following code, replacing the existing template code:
   Send a message with WhatsApp, Twilio, and C# (.NET Framework)

   Report code block

   Copy code block

   1
   // Install the C# / .NET helper library from twilio.com/docs/csharp/install
   2
   
   3
   using System;
   4
   using Twilio;
   5
   using Twilio.Rest.Api.V2010.Account;
   6
   using System.Threading.Tasks;
   7
   using System.Collections.Generic;
   8
   using Newtonsoft.Json;
   9
   
   10
   class Program {
   11
       public static async Task Main(string[] args) {
   12
           // Find your Account SID and Auth Token at twilio.com/console
   13
           // and set the environment variables. See http://twil.io/secure
   14
           string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");
   15
           string authToken = Environment.GetEnvironmentVariable("TWILIO_AUTH_TOKEN");
   16
   
   17
           TwilioClient.Init(accountSid, authToken);
   18
   
   19
           var message = await MessageResource.CreateAsync(
   20
               from: new Twilio.Types.PhoneNumber("whatsapp:+14155238886"),
   21
               to: new Twilio.Types.PhoneNumber("whatsapp:+16285550100"),
   22
               contentSid: "HXb5b62575e6e4ff6129ad7c8efe1f983e",
   23
               contentVariables: JsonConvert.SerializeObject(
   24
                   new Dictionary<string, Object>() { { "1", "22 July 2026" }, { "2", "3:15pm" } },
   25
                   Formatting.Indented));
   26
   
   27
           Console.WriteLine(message.Body);
   28
       }
   29
   }

3. Replace the value for to: new Twilio.Types.PhoneNumber with the whatsapp: prefix and your personal WhatsApp number in E.164 format. For example, whatsapp:+16285550100.
4. Save your changes and run your project in Visual Studio.

After a few moments, you receive a WhatsApp message from the Sandbox to your personal WhatsApp account.

1. Create and open a new file called Example.java in the same directory as the fat jar file and paste in the following code:

   Copy code block

   1
   import com.twilio.type.PhoneNumber;
   2
   import java.util.HashMap;
   3
   import com.twilio.Twilio;
   4
   import com.twilio.rest.api.v2010.account.Message;
   5
   import org.json.JSONObject;
   6
   
   7
   public class Example {
   8
   	public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");
   9
   	public static final String AUTH_TOKEN = System.getenv("TWILIO_AUTH_TOKEN");
   10
   
   11
   
   12
   public static void main(String[] args) {
   13
   	Twilio.init(ACCOUNT_SID, AUTH_TOKEN);
   14
   
   15
   	Message message =
   16
   		Message.creator(
   17
   				new PhoneNumber("whatsapp:+16285550100"),
   18
   				new PhoneNumber("whatsapp:+14155238886"),
   19
   				(String) null
   20
   		)
   21
   		.setContentSid("HXb5b62575e6e4ff6129ad7c8efe1f983e")
   22
   		.setContentVariables(new JSONObject(new HashMap<String, Object>() {{
   23
   				put("1", "22 July 2026");
   24
   				put("2", "3:15pm");
   25
   		}}).toString())
   26
   		.create();
   27
   
   28
   	System.out.println(message.getSid());
   29
   	}
   30
   }

2. Replace the value for the first phone number (the recipient) with the whatsapp: prefix and your personal WhatsApp number in E.164 format. For example, whatsapp:+16285550100.

3. Save your changes and compile the code from your terminal in the directory that contains Example.java. Replace 10.9.0 with the version of your fat jar file.

   Copy code block

   javac -cp twilio-10.9.0-jar-with-dependencies.jar Example.java

4. Run the code. Replace 10.9.0 with the version of your fat jar file.

   On Linux or macOS, run:

   Copy code block

   java -cp .:twilio-10.9.0-jar-with-dependencies.jar Example

   On Windows, run:

   Copy code block

   java -cp ".;twilio-10.9.0-jar-with-dependencies.jar" Example

After a few moments, you receive a WhatsApp message from the Sandbox to your personal WhatsApp account.

1. Copy and paste the following code into your terminal:

   Send a message with WhatsApp, Twilio, and curl

   Report code block

   Copy code block

   1
   CONTENT_VARIABLES_OBJ=$(cat << EOF
   2
   {
   3
     "1": "22 July 2026",
   4
     "2": "3:15pm"
   5
   }
   6
   EOF
   7
   )
   8
   curl -X POST "https://api.twilio.com/2010-04-01/Accounts/$TWILIO_ACCOUNT_SID/Messages.json" \
   9
   --data-urlencode "From=whatsapp:+14155238886" \
   10
   --data-urlencode "To=whatsapp:+16285550100" \
   11
   --data-urlencode "ContentSid=HXb5b62575e6e4ff6129ad7c8efe1f983e" \
   12
   --data-urlencode "ContentVariables=$CONTENT_VARIABLES_OBJ" \
   13
   -u $TWILIO_ACCOUNT_SID:$TWILIO_AUTH_TOKEN

2. Replace the value for To with the whatsapp: prefix and your personal WhatsApp number in E.164 format. For example, whatsapp:+16285550100.

3. Press Enter to send the request.

   The JSON body of the request prints to your terminal.

After a few moments, you receive a WhatsApp message from the Sandbox to your personal WhatsApp account.

1. Create and set up your Go project.

   1. Create a new Go project by running the following command:

      Copy code block

      go mod init twilio-example

   2. Install the Twilio Go helper library:

      Copy code block

      go get github.com/twilio/twilio-go

2. Create and open a new file called send_whatsapp.go in your Go project directory and paste in the following code:

   Send a message with WhatsApp, Twilio, and Go

   Report code block

   Copy code block

   1
   // Download the helper library from https://www.twilio.com/docs/go/install
   2
   package main
   3
   
   4
   import (
   5
   	"encoding/json"
   6
   	"fmt"
   7
   	"github.com/twilio/twilio-go"
   8
   	api "github.com/twilio/twilio-go/rest/api/v2010"
   9
   	"os"
   10
   )
   11
   
   12
   func main() {
   13
   	// Find your Account SID and Auth Token at twilio.com/console
   14
   	// and set the environment variables. See http://twil.io/secure
   15
   	// Make sure TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN exists in your environment
   16
   	client := twilio.NewRestClient()
   17
   
   18
   	ContentVariables, ContentVariablesError := json.Marshal(map[string]interface{}{
   19
   		"1": "22 July 2026",
   20
   		"2": "3:15pm",
   21
   	})
   22
   
   23
   	if ContentVariablesError != nil {
   24
   		fmt.Println(ContentVariablesError)
   25
   		os.Exit(1)
   26
   	}
   27
   
   28
   	params := &api.CreateMessageParams{}
   29
   	params.SetFrom("whatsapp:+14155238886")
   30
   	params.SetTo("whatsapp:+16285550100")
   31
   	params.SetContentSid("HXb5b62575e6e4ff6129ad7c8efe1f983e")
   32
   	params.SetContentVariables(string(ContentVariables))
   33
   
   34
   	resp, err := client.Api.CreateMessage(params)
   35
   	if err != nil {
   36
   		fmt.Println(err.Error())
   37
   		os.Exit(1)
   38
   	} else {
   39
   		if resp.Body != nil {
   40
   			fmt.Println(*resp.Body)
   41
   		} else {
   42
   			fmt.Println(resp.Body)
   43
   		}
   44
   	}
   45
   }

3. Replace the value for params.SetTo with the whatsapp: prefix and your personal WhatsApp number in E.164 format. For example, whatsapp:+16285550100.

4. Save your changes and run this command in the directory that contains send_whatsapp.go:

   Copy code block

   go run send_whatsapp.go

After a few moments, you receive a WhatsApp message from the Sandbox to your personal WhatsApp account.

1. Create and open a new file called send_whatsapp.rb anywhere on your machine and paste in the following code:

   Send a message with WhatsApp, Twilio, and Ruby

   Report code block

   Copy code block

   1
   # Download the helper library from https://www.twilio.com/docs/ruby/install
   2
   require 'rubygems'
   3
   require 'twilio-ruby'
   4
   
   5
   # Find your Account SID and Auth Token at twilio.com/console
   6
   # and set the environment variables. See http://twil.io/secure
   7
   account_sid = ENV['TWILIO_ACCOUNT_SID']
   8
   auth_token = ENV['TWILIO_AUTH_TOKEN']
   9
   @client = Twilio::REST::Client.new(account_sid, auth_token)
   10
   
   11
   message = @client
   12
             .api
   13
             .v2010
   14
             .messages
   15
             .create(
   16
               from: 'whatsapp:+14155238886',
   17
               to: 'whatsapp:+16285550100',
   18
               content_sid: 'HXb5b62575e6e4ff6129ad7c8efe1f983e',
   19
               content_variables: {
   20
                   '1' => '22 July 2026',
   21
                   '2' => '3:15pm'
   22
                 }.to_json
   23
             )
   24
   
   25
   puts message.body

2. Replace the value for to with the whatsapp: prefix and your personal WhatsApp number in E.164 format. For example, whatsapp:+16285550100.

3. Save your changes and run this command from your terminal in the directory that contains send_whatsapp.rb:

   Copy code block

   ruby send_whatsapp.rb

After a few moments, you receive a WhatsApp message from the Sandbox to your personal WhatsApp account.

1. Create and open a new file called reply_whatsapp.py anywhere on your machine and paste in the following code:

   Copy code block

   1
   from flask import Flask, request, Response
   2
   from twilio.twiml.messaging_response import MessagingResponse
   3
   
   4
   app = Flask(__name__)
   5
   
   6
   @app.route("/reply_whatsapp", methods=['POST'])
   7
   def reply_whatsapp():
   8
   	# Create a new Twilio MessagingResponse
   9
   	resp = MessagingResponse()
   10
   	resp.message("Message received! Hello again from the Twilio Sandbox for WhatsApp.")
   11
   
   12
   	# Return the TwiML (as XML) response
   13
   	return Response(str(resp), mimetype='text/xml')
   14
   
   15
   if __name__ == "__main__":
   16
   	app.run(port=3000)

   Save the file.

2. In a new terminal window, run the following command to start the Python development server on port 3000:

   Copy code block

   python reply_whatsapp.py 

3. In a new terminal window, run the following command to start ngrok and create a tunnel to your localhost:

   Copy code block

   ngrok http 3000

   (warning)

   Warning

   Use ngrok only for testing because it creates a temporary URL that exposes your local development machine to the internet. Host your application with a cloud provider or your public server when you deploy to production.

4. Set up a webhook that triggers when the Sandbox receives a WhatsApp message:

   1. Open the Try WhatsApp page in the Twilio Console.

   2. Click Sandbox settings.

   3. In the Sandbox Configuration section, in the When a message comes in field, enter the temporary forwarding URL from your ngrok console with /reply_whatsapp appended to the end.

      For example, if your ngrok console shows Forwarding https://1aaa-123-45-678-910.ngrok-free.app, enter https://1aaa-123-45-678-910.ngrok-free.app/reply_whatsapp.

   4. Click Save.

5. With the Python development server and ngrok running, send a WhatsApp message to the Sandbox number from your personal WhatsApp account.

An HTTP request shows in your ngrok console, and you receive the response message in your personal WhatsApp account.

1. Create and open a new file called server.js anywhere on your machine and paste in the following code:

   Respond to an incoming WhatsApp message with Node.js

   Report code block

   Copy code block

   1
   const express = require('express');
   2
   const { MessagingResponse } = require('twilio').twiml;
   3
   
   4
   const app = express();
   5
   
   6
   app.post('/whatsapp', (req, res) => {
   7
     const twiml = new MessagingResponse();
   8
   
   9
     twiml.message('Message received! Hello again from the Twilio Sandbox for WhatsApp.');
   10
   
   11
     res.type('text/xml').send(twiml.toString());
   12
   });
   13
   
   14
   app.listen(3000, () => {
   15
     console.log('Express server listening on port 3000');
   16
   });

2. In a new terminal window, start the Node.js development server on port 3000 by running this command in the directory that contains server.js:

   Copy code block

   node server.js

3. In a new terminal window, run the following command to start ngrok and create a tunnel to your localhost:

   Copy code block

   ngrok http 3000

   (warning)

   Warning

   Use ngrok only for testing because it creates a temporary URL that exposes your local development machine to the internet. Host your application with a cloud provider or your public server when you deploy to production.

4. Set up a webhook that triggers when the Sandbox receives a WhatsApp message:

   1. Open the Try WhatsApp page in the Twilio Console.

   2. Click Sandbox settings.

   3. In the Sandbox Configuration section, in the When a message comes in field, enter the temporary forwarding URL from your ngrok console with /whatsapp appended to the end.

      For example, if your ngrok console shows Forwarding https://1aaa-123-45-678-910.ngrok-free.app, enter https://1aaa-123-45-678-910.ngrok-free.app/whatsapp.

   4. Click Save.

5. With the Node.js development server and ngrok running, send a WhatsApp message to the Sandbox number from your personal WhatsApp account.

An HTTP request shows in your ngrok console, and you receive the response message in your personal WhatsApp account.

1. Create and open a new file called reply_whatsapp.php in the same directory as send_whatsapp.php and paste in the following code:

   Copy code block

   1
   <?php
   2
   require_once "vendor/autoload.php";
   3
   use Twilio\TwiML\MessagingResponse;
   4
   
   5
   // Set the content-type to XML to send back TwiML from the PHP Helper Library
   6
   header("content-type: text/xml");
   7
   
   8
   $response = new MessagingResponse();
   9
   $response->message(
   10
   	"Message received! Hello again from the Twilio Sandbox for WhatsApp."
   11
   );
   12
   
   13
   echo $response;

   Save the file.

2. In a new terminal window, start the PHP development server on port 3000 by running this command:

   Copy code block

   php -S localhost:3000 reply_whatsapp.php

3. In a new terminal window, run the following command to start ngrok and create a tunnel to your localhost:

   Copy code block

   ngrok http 3000

   (warning)

   Warning

   Use ngrok only for testing because it creates a temporary URL that exposes your local development machine to the internet. Host your application with a cloud provider or your public server when you deploy to production.

4. Set up a webhook that triggers when the Sandbox receives a WhatsApp message:

   1. Open the Try WhatsApp page in the Twilio Console.

   2. Click Sandbox settings.

   3. In the Sandbox Configuration section, in the When a message comes in field, enter the temporary forwarding URL from your ngrok console.

      For example, if your ngrok console shows Forwarding https://1aaa-123-45-678-910.ngrok-free.app, enter https://1aaa-123-45-678-910.ngrok-free.app.

   4. Click Save.

5. With the PHP development server and ngrok running, send a WhatsApp message to the Sandbox number from your personal WhatsApp account.

An HTTP request shows in your ngrok console, and you receive the response message in your personal WhatsApp account.

1. Create a new ASP.NET MVC Project in Visual Studio:

   1. Open Visual Studio and click Create a new project.
   2. Click ASP.NET Web Application (.NET Framework).
   3. Click MVC to select the project type.
   4. Use the NuGet Package Manager to install the Twilio.AspNet.Mvc package.

2. Create a new controller:

   1. Open the project directory.
   2. Right-click on the Controllers folder.
   3. Select Add > Controller... > MVC 5 Controller - Empty.
   4. Name the file WhatsappController.cs.

3. Paste the following code into WhatsappController.cs:

   Copy code block

   1
   // Code sample for ASP.NET MVC on .NET Framework 4.6.1+
   2
   // In Package Manager, run:
   3
   // Install-Package Twilio.AspNet.Mvc -DependencyVersion HighestMinor
   4
   
   5
   using Twilio.AspNet.Common;
   6
   using Twilio.AspNet.Mvc;
   7
   using Twilio.TwiML;
   8
   
   9
   namespace WebApplication1.Controllers
   10
   {
   11
   	public class WhatsappController : TwilioController
   12
   	{
   13
   		public TwiMLResult Index(WhatsappRequest incomingMessage)
   14
   		{
   15
   			var messagingResponse = new MessagingResponse();
   16
   			messagingResponse.Message("Message received! Hello again from the Twilio Sandbox for WhatsApp.");
   17
   
   18
   			return TwiML(messagingResponse);
   19
   		}
   20
   	}
   21
   }

   Save the file.

4. In Visual Studio, run the application by clicking the play arrow. Your web browser opens on a localhost URL. Note the port number; for example, if the URL opens on https://localhost:44360, your port number is 44360.

5. In a new terminal window, run the following command to start ngrok and create a tunnel to your localhost. Replace PORT with the port number from your application.

   Copy code block

   ngrok http PORT

   (warning)

   Warning

   Use ngrok only for testing because it creates a temporary URL that exposes your local development machine to the internet. Host your application with a cloud provider or your public server when you deploy to production.

6. Set up a webhook that triggers when the Sandbox receives a WhatsApp message:

   1. Open the Try WhatsApp page in the Twilio Console.

   2. Click Sandbox settings.

   3. In the Sandbox Configuration section, in the When a message comes in field, enter the temporary forwarding URL from your ngrok console with /whatsapp appended to the end.

      For example, if your ngrok console shows Forwarding https://1aaa-123-45-678-910.ngrok-free.app, enter https://1aaa-123-45-678-910.ngrok-free.app/whatsapp.

   4. Click Save.

7. With the application and ngrok running, send a WhatsApp message to the Sandbox number from your personal WhatsApp account.

An HTTP request shows in your ngrok console, and you receive the response message in your personal WhatsApp account.

1. Create and set up the IntelliJ project.

   1. Open IntelliJ IDEA Community Edition.

   2. Create a new project with either Maven or Gradle as the build system.

   3. Add the following dependencies to your Maven or Gradle build file:

      • com.twilio.sdk:twilio
      • com.sparkjava:spark-core
      • org.slf4j

      To learn more about the dependencies, see SparkJava and Simple Logging Facade 4 Java (SLF4J).

   4. Select the java folder under src > main.

   5. To create a new Java class, click File > New > Java Class. Name the class WhatsappApp.

2. In the new WhatsappApp.java file that IntelliJ creates, paste in the following code:

   Respond to an incoming WhatsApp message with Java

   Report code block

   Copy code block

   1
   import com.twilio.twiml.MessagingResponse;
   2
   import com.twilio.twiml.messaging.Body;
   3
   import com.twilio.twiml.messaging.Message;
   4
   
   5
   import static spark.Spark.*;
   6
   
   7
   public class WhatsAppApp {
   8
       public static void main(String[] args) {
   9
           get("/", (req, res) -> "Hello Web");
   10
   
   11
           post("/whatsapp", (req, res) -> {
   12
               res.type("application/xml");
   13
               Body body = new Body
   14
                       .Builder("Message received! Hello again from the Twilio Sandbox for WhatsApp.")
   15
                       .build();
   16
               Message whatsapp = new Message
   17
                       .Builder()
   18
                       .body(body)
   19
                       .build();
   20
               MessagingResponse twiml = new MessagingResponse
   21
                       .Builder()
   22
                       .message(whatsapp)
   23
                       .build();
   24
               return twiml.toXml();
   25
           });
   26
       }
   27
   }

3. Right-click on the WhatsappApp class in the project outline and choose Run 'WhatsappApp.main()'.

   The Java spark web application server starts listening on port 4567.

4. In a new terminal window, run the following command to start ngrok and create a tunnel to your localhost:

   Copy code block

   ngrok http 4567

   (warning)

   Warning

   Use ngrok only for testing because it creates a temporary URL that exposes your local development machine to the internet. Host your application with a cloud provider or your public server when you deploy to production.

5. Set up a webhook that triggers when the Sandbox receives a WhatsApp message:

   1. Open the Try WhatsApp page in the Twilio Console.

   2. Click Sandbox settings.

   3. In the Sandbox Configuration section, in the When a message comes in field, enter the temporary forwarding URL from your ngrok console with /whatsapp appended to the end.

      For example, if your ngrok console shows Forwarding https://1aaa-123-45-678-910.ngrok-free.app, enter https://1aaa-123-45-678-910.ngrok-free.app/whatsapp.

   4. Click Save.

6. With the Java development server and ngrok running, send a WhatsApp message to the Sandbox number from your personal WhatsApp account.

An HTTP request shows in your ngrok console, and you receive the response message in your personal WhatsApp account.

Although we're sure it's possible to run a server from your command line, we suggest exploring how to set up your environment, send messages, and respond to messages with TwiML in the programming language of your choice.

To respond to messages, you'll set up a webhook that triggers when the Sandbox receives a WhatsApp message. You can configure webhooks by connecting the Sandbox to an app you've already built for handling incoming messages, or build a new one for WhatsApp messages.

1. Create and open a new file called server.go in your Go project directory and paste in the following code:

   Respond to an incoming WhatsApp message with Go

   Report code block

   Copy code block

   1
   package main
   2
   
   3
   import (
   4
   	"net/http"
   5
   
   6
   	"github.com/gin-gonic/gin"
   7
   	"github.com/twilio/twilio-go/twiml"
   8
   )
   9
   
   10
   func main() {
   11
   	router := gin.Default()
   12
   
   13
   	router.POST("/whatsapp", func(context *gin.Context) {
   14
   		message := &twiml.MessagingMessage{
   15
   			Body: "Message received! Hello again from the Twilio Sandbox for WhatsApp.",
   16
   		}
   17
   
   18
   		twimlResult, err := twiml.Messages([]twiml.Element{message})
   19
   		if err != nil {
   20
   			context.String(http.StatusInternalServerError, err.Error())
   21
   		} else {
   22
   			context.Header("Content-Type", "text/xml")
   23
   			context.String(http.StatusOK, twimlResult)
   24
   		}
   25
   	})
   26
   
   27
   	router.Run(":3000")
   28
   }

2. Install the Gin Framework:

   Copy code block

   go get -u github.com/gin-gonic/gin

3. Install the TwiML dependency:

   Copy code block

   go get github.com/twilio/twilio-go/twiml@latest

4. In a new terminal window, start the Go development server on port 3000 by running this command in the directory that contains server.go:

   Copy code block

   go run server.go

5. In a new terminal window, run the following command to start ngrok and create a tunnel to your localhost:

   Copy code block

   ngrok http 3000

   (warning)

   Warning

   Use ngrok only for testing because it creates a temporary URL that exposes your local development machine to the internet. Host your application with a cloud provider or your public server when you deploy to production.

6. Set up a webhook that triggers when the Sandbox receives a WhatsApp message:

   1. Open the Try WhatsApp page in the Twilio Console.

   2. Click Sandbox settings.

   3. In the Sandbox Configuration section, in the When a message comes in field, enter the temporary forwarding URL from your ngrok console with /whatsapp appended to the end.

      For example, if your ngrok console shows Forwarding https://1aaa-123-45-678-910.ngrok-free.app, enter https://1aaa-123-45-678-910.ngrok-free.app/whatsapp.

   4. Click Save.

7. With the Go development server and ngrok running, send a WhatsApp message to the Sandbox number from your personal WhatsApp account.

An HTTP request shows in your ngrok console, and you receive the response message in your personal WhatsApp account.

1. Create and open a new file called reply_whatsapp.rb in the same directory as Gemfile and paste in the following code:

   Copy code block

   1
   require 'twilio-ruby'
   2
   require 'sinatra'
   3
   
   4
   # disable HostAuthorization for development only
   5
   configure :development do
   6
   	set :host_authorization, { permitted_hosts: [] }
   7
   end
   8
   
   9
   post '/whatsapp' do
   10
   	twiml = Twilio::TwiML::MessagingResponse.new do |r|
   11
   		r.message(body: 'Message received! Hello again from the Twilio Sandbox for WhatsApp.')
   12
   	end
   13
   
   14
   	twiml.to_s
   15
   end

   Save the file.

2. In a new terminal window, start the Ruby development server on port 4567 by running this command:

   Copy code block

   ruby reply_whatsapp.rb

3. In a new terminal window, run the following command to start ngrok and create a tunnel to your localhost:

   Copy code block

   ngrok http 4567

   (warning)

   Warning

   Use ngrok only for testing because it creates a temporary URL that exposes your local development machine to the internet. Host your application with a cloud provider or your public server when you deploy to production.

4. Set up a webhook that triggers when the Sandbox receives a WhatsApp message:

   1. Open the Try WhatsApp page in the Twilio Console.

   2. Click Sandbox settings.

   3. In the Sandbox Configuration section, in the When a message comes in field, enter the temporary forwarding URL from your ngrok console with /whatsapp appended to the end.

      For example, if your ngrok console shows Forwarding https://1aaa-123-45-678-910.ngrok-free.app, enter https://1aaa-123-45-678-910.ngrok-free.app/whatsapp.

   4. Click Save.

5. With the Ruby development server and ngrok running, send a WhatsApp message to the Sandbox number from your personal WhatsApp account.

An HTTP request shows in your ngrok console, and you receive the response message in your personal WhatsApp account.