Azure Blob Storage, AWS, and Twilio keys all up for grabs

Millions of mobile app users at risk from hardcoded creds • The Register

Twilio (TWLO) closed the most recent trading day at $61.91, moving +0.52% from the previous trading session.

Twilio (TWLO) Advances But Underperforms Market: Key Facts

Public Employees Retirement System of Ohio lessened its stake in Twilio Inc. (NYSE:TWLO – Free Report) by 9.8% in the 3rd quarter, according to its most recent 13F filing with the Securities and Exchange Commission. The institutional investor owned 69,515 shares of the technology company’s ...

Public Employees Retirement System of Ohio Has $4.07 Million Holdings in Twilio Inc. (NYSE:TWLO) - Defense World

At Yahoo Finance, you get free stock quotes, the latest news, portfolio management resources, international market data, social interaction and mortgage rates to help you manage your financial life.

Vanguard Group Inc. boosted its holdings in shares of Twilio Inc. (NYSE:TWLO – Free Report) by 2.6% during the third quarter, according to the company in its most recent Form 13F filing with the Securities &amp; Exchange Commission. The fund owned 17,567,835 shares of the technology company’s ...

Vanguard Group Inc. Has $1.03 Billion Holdings in Twilio Inc. (NYSE:TWLO) - Defense World

B. Riley Wealth Advisors Inc. trimmed its position in Twilio Inc. (NYSE:TWLO – Free Report) by 16.7% during the third quarter, according to the company in its most recent 13F filing with the SEC. The firm owned 10,793 shares of the technology company’s stock after selling 2,161 shares during ...

B. Riley Wealth Advisors Inc. Sells 2,161 Shares of Twilio Inc. (NYSE:TWLO) - Defense World

The Zacks Style Scores offers investors a way to easily find top-rated stocks based on their investing style. Here&#x27;s why you should take advantage.

Here's Why Twilio (TWLO) is a Strong Momentum Stock

CX Today covers Data &amp; Analytics news including CpaaS and more.

Twilio Refuses to Sell Segment, Appoints New President to Oversee the Business - CX Today

An email marketing automation platform designed for large-scale campaigns

Twilio SendGrid Marketing Campaigns - Review 2024 - PCMag Middle East

Activist investors want Twilio to sell off its underperforming Segment business and focus on its original communications business. Read more on TWLO stock here.

Twilio: Repeating A Failed Plan, Hoping For A Different Outcome (NYSE:TWLO) | Seeking Alpha

Twilio

twilio

How to Build a Secure Anonymous Feedback System With Django, Twilio, and Pinata

Because Twilio has high name recognition, many organizations consider it first when investigating communications platforms as a service (CPaaS). After trying Twilio, though, they may find themselves less than completely satisfied, maybe because of high pricing or unsatisfactory support or some other factor. Fortunately, highly regarded Twilio alternatives can help ease the pain. We suggest Plivo, which earns the among cloud communications platforms on G2. highest marks for customer satisfaction If you’re not satisfied with Twilio, you don’t have to rip it out and replace it with a Twilio alternative. You can put Plivo in place for a pilot program for a single use case and see how it performs. If you’re satisfied, you can switch over, or you can use Plivo in parallel with Twilio, or as a backup alternative in case your primary provider experiences downtime. Migrating from Twilio to Plivo is simple. The two companies’ API structures, implementation mechanisms, XML structure, SMS message processing, and voice call processing are similar. Twilio and Plivo enjoy feature parity in virtually every aspect, including Voice API SMS/MMS API Programmatically managing call flows Geo permissions Number lookup API Phone number management Validating requests Subaccounts Speech recognition SSML (Speech Synthesis Markup Language) Browser and mobile SDKs Transcription Custom SIP headers HTTP callbacks You can migrate your existing application from Twilio to Plivo by refactoring the code, or you can try Plivo High-Level Objects (PHLO), an intuitive visual workflow builder. Follow one of Plivo’s quickstart guides for your preferred language and web framework. Plivo offers server SDKs in seven languages: PHP, Node.js, .NET, Java, Python, Ruby, and Go. How to Make an Outbound Call Let’s take a look at the code for a Ruby application that makes an outbound call in both Twilio to Plivo. Whether you use Ruby or one of the other supported languages, you can migrate from one platform to the other by refactoring just a few lines of code. Twilio require 'rubygems'
require 'twilio-ruby'

account_sid = ENV['<TWILIO_ACCOUNT_SID>']
auth_token = ENV['<TWILIO_AUTH_TOKEN>']
@client = Twilio::REST::Client.new(account_sid, auth_token)

call = @client.calls.create(
            url: 'http://demo.twilio.com/docs/classic.mp3',
            to: '+1415555222',
            from: '+14155551111'
)
puts call.sid Plivo require 'rubygems'
require 'plivo'

include Plivo
include Plivo::Exceptions

auth_id = ENV['<PLIVO_AUTH_ID>']
auth_token = ENV['<PLIVO_AUTH_TOKEN>']

api = RestClient.new(auth_id,auth_token)

begin
  response = api.calls.create(
    '+14155551111',
    ['+14155552222'],
    'https://s3.amazonaws.com/static.plivo.com/answer.xml'
  )

  puts response
rescue PlivoRESTError => e
  puts 'Exception: ' + e.message
end How to Receive an Incoming Call You can migrate an application for receiving and handling an incoming call just as easily. Twilio require 'sinatra'
require 'twilio-ruby'

post '/twiml' do
 # Start our TwiML response
 Twilio::TwiML::VoiceResponse.new do |r|
 r.say(message: 'Hello, world!', voice: 'alice')
 end.to_s
end Plivo include Plivo
include Plivo::XML
include Plivo::Exceptions

class PlivoController < ApplicationController
 def inbound
 response = Response.new
 speak_body = 'Hello, world!'
 response.addSpeak(speak_body)

 xml = Plivo::PlivoXML.new(response)
 render xml: xml.to_xml
 end
end How to Forward an Incoming Call The same goes for an application that automatically forwards an incoming call. Twilio require 'sinatra'
require 'twilio-ruby'

post '/twiml' do

 response = Twilio::TwiML::VoiceResponse.new
 response.dial(number: '415-234-5678')
 response.say(message: 'Goodbye')
 puts response
 end.to_s
end Plivo def forward
 response = Response.new
 dial = response.addDial()
 dest_number = "415-234-5678"
 dial.addNumber(dest_number)

 xml = PlivoXML.new(response)
 puts xml.to_xml
 render xml: xml.to_xml
 end We don’t want to overload you with code here (especially if you use a language other than Ruby). You can get more information about how to implement voice applications in Plivo from the , available for all seven programming languages and PHLO. use case guide documentation One of Plivo’s key principles is to keep things simple for developers while we allow them to build complex applications. See for yourself how simple it is for a Twilio developer to pick up Plivo. Simple and Reliable Plivo’s simple APIs work in tandem with a comprehensive global network to let you build robust voice applications with low latency and high call quality. See for yourself by signing up for a free Plivo trial account that you can experiment with, which comes with free credits.

Migrating a Voice-Enabled Application 
from Twilio to Plivo

I've recently become obsessed with , a word puzzle game created by Brooklyn-based software engineer for his word game-loving partner. As a homage to Josh, and just-for-fun, I created a version of the game that can be played via text message. Read on to learn how to build an SMS word game using the , , the , , and , and play Twordle yourself: ! Wordle Josh Wardle Dictionary API Twilio Functions Twilio Serverless Toolkit Twilio Assets cookies in Twilio Runtime text a 5-letter word or "?" to +12155156567 Prerequisites A Twilio account - sign up for a free one here and receive an extra $10 if you upgrade through this link A Twilio phone number with SMS capabilities - configure one here Node.js installed - download it here Get Started with the Twilio Serverless Toolkit The Serverless Toolkit is CLI tooling that helps you develop locally and deploy to . The best way to work with the Serverless Toolkit is through the . If you don't have the Twilio CLI installed yet, run the following commands on the command line to install it and the Serverless Toolkit: Twilio Runtime Twilio CLI npm install twilio-cli -g
twilio login
twilio plugins:install @twilio-labs/plugin-serverless Create your new project and install our lone requirement , an HTTP client library to make HTTP requests in Node.js, by running: got twilio serverless:init twordle
cd twordle
npm install got Add a Static Text File to Twilio Assets Twilio Assets is a static file hosting service that allows developers to quickly upload and serve the files needed to support their applications. We want our Twilio Asset to be private–this means it will not be accessible by URL or exposed to the web; rather, it will be packaged with our Twilio Function at build time. . For more information on Private, Public, and Protected Assets, check out this page Copy this and add it to our folder as . We will read the file from our Twilio Function and generate a random word from it that will be used for each Wordle game. The word will be different for each person, and each person can play multiple times a day. GitHub file containing five-letter words from the English dictionary Assets words.private.text Write the Word Game Logic with JavaScript into the directory and make a new file called game.js containing the following code to import the module, read the file from Twilio Assets, create a function to return a random word from the Asset, and initialize two constants (the user always has five chances to guess the word, and all the words are five letters): cd \functions got words.txt randomWord const got = require('got');
let words = Runtime.getAssets()['/words.txt'].open().toString().split("\n");
const randomWord = () => {
 return words[words.length * Math.random() | 0];
}
const maxGuesses = 5;
const wordLength = 5; Next we have the meaty function that takes in a parameter (an object representing each player), and a guess (the word they text in as a guess.) We make a score card which will contain the boxes we return based on how close the user's guess is to the generated random word. In a block, we make an HTTP request with to the dictionary API using : if the page exists, the guess is a word, and we increment the attribute of the player object. For each letter in the guess, we check if it is in the goal word: if a letter is in the same spot, that spot in the score card will contain a green square (🟩). If a letter in the guess is not in the same index as the generated word for the player but the letter is in the generated word, the score card will contain a yellow square (🟨). Else, the score card will contain a black square (⬛). If our HTTP request is unsuccessful, our score card will be a string telling the user to try again. handleGuess player try got guess guessesAttempted const handleGuess = async (player, guess) => {
 let newScoreCard = [];
 try {
 const response = await got(`https://api.dictionaryapi.dev/api/v2/entries/en/${guess}`).json();
 if (response.statusCode !== 404) {
 player.guessesAttempted+=1;
 for (let i = 0; i < guess.length; i++) {
 if (guess.charAt(i) == player.randWord.charAt(i)) {
 if (player.dupLetters[i] != null) {
 player.numCorrectLetters+=1;
 }
 player.dupLetters[i] = null;
 newScoreCard.push('🟩');
 } else if (guess.charAt(i) != player.randWord.charAt(i) && player.randWord.includes(guess.charAt(i))) {
 newScoreCard.push('🟨');
 } else {
 if (!player.incorrectLettersArr.includes(guess.charAt(i))); {
 player.incorrectLettersArr.push(guess.charAt(i));
 }
 newScoreCard.push('⬛');
 }
 }
 console.log(`newScoreCard ${newScoreCard}`);
 return newScoreCard;
 } 
 else { //404 word not in dict
 newScoreCard = "word not found in dictionary! try again!";
 console.log('Word not found!');
 return newScoreCard;
 }
 }
 catch (err) {
 newScoreCard = "word not found in dictionary! try again!";
 console.log('Word not found!');
 return newScoreCard;
 } 
} After our function to handle each guess, let's make a function to check if the game is over. For parameters it accepts the object and . If the number of attempted guesses for the player is greater than or equal to five (the most number of guesses a player can have), the number of correct letters guessed is equal to the word length (five), or the score card contains five green squares, the game is over and returns true. Else, the game continues and returns false. player scoreCard endFunc const endFunc = (player, scoreCard) => {
 if (player.guessesAttempted >= maxGuesses) { 
 console.log(`guessesAttempted >= maxGuesses`);
 return true;
 }
 else if (player.numCorrectLetters == wordLength) {
 console.log("in numCorrect");
 return true;
 }
 else if(scoreCard == `🟩,🟩,🟩,🟩,🟩`) {
 console.log(`scorecard = 🟩,🟩,🟩,🟩,🟩`);
 return true;
 }
 else {
 console.log(`game still going`);
 return false;
 }
} Call Game Logic in Twilio Functions' Handler Method The handler method is like the entry point to your app, similar to a function in Java or in Python. In this tutorial, it will run each time someone texts our Twilio number. . main() __init__ For more information on Function invocation and execution, read this page First in the method, we initialize a Twilio Messaging Response object to respond to the player's guess text message, a variable which is whatever the player texted in, a string as empty text that we will append to depending on the guess, create a Twilio Response object to handle memory management with cookies,and a object whose attributes we will initialize based on the guess. guess responseText player exports.handler = async function(context, event, callback) {
 let twiml = new Twilio.twiml.MessagingResponse();
 let responseText = '';
 let guess = event.Body.toLowerCase().trim();
 let response = new Twilio.Response();
 let player; If the player texts in a question mark, we return a message about Josh Wardle who made the game as well as instructions on how to play the game. if (guess == "?") {
 twiml.message(`Wordle was made by Josh Wardle, a Brooklyn-based software engineer, for his partner who loves word games. You guess a 5-letter word and the responding tiles reflect how close your guess was to the goal word. 🟩 means a letter was in the right spot, 🟨 means the letter was correct but in the wrong spot, and ⬛️ means the letter is not in the goal word.`)
 return callback(null, twiml); //no need for cookies
 } Then we check if the player has texted in before. If the player does not exist, we generate a new word for them and initialize a new player object with the random word, the guesses attempted (none so far), number of correct letters (none so far), an array of duplicate letters, and an array of incorrect letters guessed (currently empty.) If the player does exist, we pull data off the cookie to get the player state and make that the object. with cookies player if (!event.request.cookies.player) { //any guesses attempted? -> new player
 let randWord = randomWord(); //new random word
 player = { //init new player
 randWord: randWord, 
 guessesAttempted: 0,
 numCorrectLetters: 0,
 dupLetters: [...randWord],
 incorrectLettersArr: []
 }
 } else { //else pull data off cookie to get player state
 player = JSON.parse(event.request.cookies.player);
 } We check the length of the guess and if it's five letters, we run the method and pass it and from above. We then check if the game is over and if it was a win, we send a congratulatory response; otherwise if it's a loss, we send a more apologetic message. Under both conditions, we remove the from cookie memory to start the player over using . handleGuess player guess player response.removeCookie("player"); If the game is not over, the response message is the scorecard with squares and we save the game state with the object with . It's in that we also set a four-hour time limit so the user has four hours to guess before the game state is lost–the default time limit for cookies in a Twilio Function is one hour. Lastly, if the guess is not five letters-long, we tell the player to send a five-letter word. player response.setCookie setCookie if (guess.length == wordLength) { //5 letters
 let scoreCard = await handleGuess(player, guess); //guessesAttempted increments
 console.log(`scoreCard ${scoreCard}`);
 if(endFunc(player, scoreCard)) { //over, win
 if(guess == player.randWord) {
 responseText += `Nice🔥! You guessed the right word in ${player.guessesAttempted}/${maxGuesses} guesses. You can play again by sending a 5-letter word to guess a new random word 👀 \nThanks for playing our SMS Twordle game. Do head to https://www.powerlanguage.co.uk/wordle for web-based word fun! Original Wordle creator Josh Wardle: as fellow builders we salute you and thank you for inspiring us to create our SMS experiment`
 response.removeCookie("player");
 }
 else if (guess != player.randWord) { //over, lose
 responseText += `Game over 🙈\nThe correct word was ${player.randWord}. Send a 5-letter guess to play again! \nThanks for playing our SMS Twordle game. Do head to https://www.powerlanguage.co.uk/wordle for web-based word fun! Original Wordle creator Josh Wardle: as fellow builders we salute you and thank you for inspiring us to create our SMS experiment`;
 response.removeCookie("player");
 }
 }
 else { //keep guessing, not over
 responseText += `${scoreCard.toString()} \n${player.guessesAttempted}/${maxGuesses} guesses`;
 response.setCookie("player", JSON.stringify(player), [
 'Max-Age=14400' //4 hour time-limit
 ]);
 }
 }
 else { //not 5 letters
 responseText += `"${guess}" is not valid. Please send a word in the dictionary that is 5 letters to get started!`;
 // twiml.message(`"${guess}" is not valid. Please send a word in the dictionary that is 5 letters to get started!`);
 console.log(`randWord ${player.randWord} in invalid `);
 } At the bottom of the handler method we append header, add information to our response about playing if the player has only guessed one time, send our in , and add twiml to return to our Twilio Response to both send our response text message to the player as well as update the object in cookie memory. responseText twiml.message player response.appendHeader('Content-Type', 'text/xml');
 // see if player.guessesAttempted == 1
 if (player.guessesAttempted == 1) {
 responseText += `\nText "?" for help on how to play`
 }
 twiml.message(responseText);
 response.setBody(twiml.toString());
 return callback(null, response); Wow that was a lot! The complete handler method is below. exports.handler = async function(context, event, callback) {
 let twiml = new Twilio.twiml.MessagingResponse();
 let responseText = '';
 let guess = event.Body.toLowerCase().trim();
 let response = new Twilio.Response();
 let player;
 if (guess == "?") {
 twiml.message(`Wordle was made by Josh Wardle, a Brooklyn-based software engineer, for his partner who loves word games. You guess a 5-letter word and the responding tiles reflect how close your guess was to the goal word. 🟩 means a letter was in the right spot, 🟨 means the letter was correct but in the wrong spot, and ⬛️ means the letter is not in the goal word.`)
 return callback(null, twiml); //no need for cookies
 }
 
 if (!event.request.cookies.player) { //any guesses attempted? -> new player
 let randWord = randomWord(); //new random word
 player = { //init new player
 randWord: randWord, 
 guessesAttempted: 0,
 numCorrectLetters: 0,
 dupLetters: [...randWord],
 incorrectLettersArr: []
 }
 } else { //else pull data off cookie to get player state
 player = JSON.parse(event.request.cookies.player);
 }
 
 if (guess.length == wordLength) { //5 letters
 let scoreCard = await handleGuess(player, guess); //guessesAttempted increments
 console.log(`scoreCard ${scoreCard}`);
 if(endFunc(player, scoreCard)) { //over, win
 if(guess == player.randWord) {
 responseText += `Nice🔥! You guessed the right word in ${player.guessesAttempted}/${maxGuesses} guesses. You can play again by sending a 5-letter word to guess a new random word 👀 \nThanks for playing our SMS Twordle game. Do head to https://www.powerlanguage.co.uk/wordle for web-based word fun! Original Wordle creator Josh Wardle: as fellow builders we salute you and thank you for inspiring us to create our SMS experiment`
 response.removeCookie("player");
 }
 else if (guess != player.randWord) { //over, lose
 responseText += `Game over 🙈\nThe correct word was ${player.randWord}. Send a 5-letter guess to play again! \nThanks for playing our SMS Twordle game. Do head to https://www.powerlanguage.co.uk/wordle for web-based word fun! Original Wordle creator Josh Wardle: as fellow builders we salute you and thank you for inspiring us to create our SMS experiment`;
 response.removeCookie("player");
 }
 }
 else { //keep guessing, not over
 responseText += `${scoreCard.toString()} \n${player.guessesAttempted}/${maxGuesses} guesses`;
 console.log(`randWord in not over ${player.randWord}`);
 response.setCookie("player", JSON.stringify(player), [
 'Max-Age=14400' //4 hour time-limit
 ]);
 }
 }
 else { //not 5 letters
 responseText += `"${guess}" is not valid. Please send a word in the dictionary that is 5 letters to get started!`;
 // twiml.message(`"${guess}" is not valid. Please send a word in the dictionary that is 5 letters to get started!`);
 console.log(`randWord ${player.randWord} in invalid `);
 }
 response.appendHeader('Content-Type', 'text/xml');
 // see if player.guessesAttempted == 1
 if (player.guessesAttempted == 1) {
 responseText += `\nText "?" for help on how to play`
 }
 // Add something to responseText that says: "Text 'HELP' for help" or whatever
 twiml.message(responseText);
 response.setBody(twiml.toString());
 return callback(null, response);
}; You can . view the complete code on GitHub here Configure the Function with a Twilio Phone Number To open up our app to the web with a public-facing URL, go back to the twordle root directory and run . Grab the link ending in . In the phone numbers section of your Twilio Console, select a purchased Twilio phone number and scroll down to the Messaging section. Under , change to and then under select , for select , and then for select . twilio serverless:deploy /game A MESSAGE COMES IN Webhook Function Service Twordle Environment dev-environment Function Path /game Click the button below and tada🎉! You can now text your Twilio number a 5-letter word to get started playing Twordle! Save What's Next for Twilio Serverless, Assets, and Word Games? Twilio's Serverless Toolkit makes it possible to deploy web apps quickly, and Twilio Runtime seamlessly handles servers for you. Let me know online what you're building with Serverless and what your current Wordle streak is! Mine is Wordle 208 5/6 ⬛⬛⬛⬛⬛ 🟧🟧⬛⬛⬛ 🟧🟧⬛⬛⬛ 🟧🟧⬛🟧⬛ 🟧🟧🟧🟧🟧 Twitter: @lizziepika GitHub: elizabethsiegle Email: lsiegle@twilio.com Livestreams: lizziepikachu

Build a Wordle-like SMS game with Twilio Serverless in JavaScript

It's not every day that you're given the opportunity to play in the desert for work — let alone launch code into space! This year, as part of SIGNAL, Twilio's user conference, and in celebration of , I was able to put aside my daily duties of writing documentation and tutorials to take part in the once-in-a-lifetime opportunity: giving SIGNAL attendees the ability to run their code in the stratosphere. the launch of TwilioQuest 3.2 Twilio collaborated with (NCL) to plan the flight and design the payload of the high-altitude, helium balloon. The balloon itself was equipped with a parachute, a radar reflector to prevent aircraft collisions, and a styrofoam box holding GoPros, an Atomos Shinobi V 7” Professional Monitor, and a Raspberry Pi 4 Model B. Night Crew Labs During Day One of SIGNAL, Twilio solicited code submissions for the mission, which we dubbed Talon 1. The code was required to be a small webpage that could be viewed offline (because in space, no one can hear your API calls). Kevin Whinnery, the creator of TwilioQuest, wrote some JavaScript to show the submissions on a loop, which would be displayed on the balloon’s monitor. (Check out how he did this on the .) NCL loaded this onto the Raspberry Pi the night before the launch. Talon GitHub Repository Day Two of SIGNAL was launch day. I left my Las Vegas hotel at 4:30 AM and drove southwest into the desert. Our crew of five Twilio employees, four NCL scientists, two cars, a pickup truck, and an adventure van named Megan met up on some Bureau of Land Management land just off of Joshua Tree Highway near Searchlight, Nevada. As the sun rose over the desert, NCL inflated the balloon and prepared the payload. On camera, I interviewed Bryan Chan, the CEO of NCL. Our audio equipment was unfortunately not up to the task, so not much of that footage made it to our audience. We were still able to pull together some footage of the launch site, which you can . check out here By about 7:30 in the morning, the balloon was inflated, the Raspberry Pi and monitor were tested, the payload was taped closed and attached to the balloon with a paracord. It was time to launch. We counted down and let the balloon go. Talon 1 was launched! As the balloon was ascending to 94,000 feet and travelling east, an onboard GoPro recorded the code submissions on the monitor with a view of Earth in the background. Our plan was to recover the balloon (fingers crossed) and return the video to each person who submitted code to our Talon 1 Repository. The submissions ranged from funny to promotional to heartwarming. One submission had a series of photos of a dog going to space in a spacesuit. A few submissions promoted businesses by showing their owners or their logos. We even teamed up with Product Hunt to send their . Others included thank yous to friends, photos of family members and pets, and memorials for loved ones. kitty mascot out to space As the balloon flies, the distance from launch to landing was about 20 miles. But that 20 miles included two mountain ranges and the Colorado River, making our drive to the recovery zone over 100 miles. During the drive, we were able to track the balloon’s altitude and position thanks to a satellite link on the payload. The balloon landed, and it appeared to be about three-fourths of a mile from a road. We parked the cars and started hiking up the sandhills. We kept cresting hills, seeing no sign of the parachute, saying “it’s probably over the next ridge”, wash, rinse, repeat. Suddenly, the sandhills ended and we realized that we were on the edge of a mountain range, 3,000 feet above the Colorado River valley below. It was jaw-droppingly beautiful, but no sign of the parachute or the payload. Thanks to Dr. Ashish Goel from the NCL team we were able to retrieve the payload. He not only has a Ph.D. in Aeronautics and Astronautics, he’s also an accomplished mountaineer. He climbed down into the steep, rocky gully to look for the payload. We couldn’t see him in the canyon, but he yelled that he spotted the parachute. A while later, he found the payload. He said the terrain was dangerous, which meant that it was absolutely not safe for anyone else to assist. After what seems like a long while, we see him walking up the slope with the Talon 1 styrofoam box. Everything was intact, everything worked as expected. As soon as we had Talon 1 in hand, it was a rush to get back to the cars, gather the SD cards from the GoPros, and get back to civilization to share our footage with the Twilio community before SIGNAL ended. The mission was certainly a bit more exciting and challenging than I thought it would be, but Night Crew Labs and the amazing Twilio employees who so thoroughly planned and executed this adventure were a dream to work with. I’m so grateful that I got to take part in giving such a unique gift to our developer community, and I hope that the TwilioQuest Space Program is a permanent feature of the Twilio community in the future.

How Twilio Sent Code to Space 

This week the API-based communications platform giant Twilio formally announced that it would acquire the customer data platform startup Segment for $3.2 billion in all stocks. The market responded quite positively to the news, driving Twilio’s stock price up by 7.7%, bring Twilio’s market cap to a staggering $49 billion. Founded in 2011, Segment is a San Francisco-based startup with the promise to disrupt traditional CRM with a seamless experience powered by customer data infrastructure. It has raised a total funding of $284 million from Thrive Capital, Sapphire Ventures, Accel & GV, among others. It was recently valued at $1.5 billion, after raising the new round in Apr 2019 to deepen its core data infrastructure platform and, more importantly, to fuel its global expansion. It is estimated that the Segment’s annual recurring revenue could reach $100 million by end of 2020, with more than 75% non-GAAP gross margins on its subscription-based revenue from over 20k customers. The $3.2 billion acquisition of Segment is by far Twilio’s largest M&A deal, beyond the $2 billion all-stock privatization of the API-centric email platform SendGrid, a major competitor of MailChimp, back 2018. “This is a once-in-a-lifetime opportunity to bring together the two leading developer-focused communications platforms to create the unquestioned platform of choice for all companies looking to transform their customer engagement,” said Twilio co-founder and CEO Jeff Lawson. Global Competition The news of the Twilio-Segment acquisition was first broke by Forbes on Friday, Oct 9, only 1 day (by US time) after Twilio’s competitor MessageBird raised a mega Series C of $200M led by Spark Capital, valuing the Dutch company at $3 billion. Founded in 2016 from Amsterdam, MessageBird has been establishing itself as the international archrival of Twilio, much like its Dutch fellow Fintech superstar Adyen compared to Stripe from San Francisco in their early days. Therefore, Twilio’s acquisition of Segment would also help it strengthen its global foothold to compete against MessageBird armed with fresh dry powder. Long Term Vision Besides competing for global market share, the more essential synergy of the combined new company comes from better achieving Twilio’s vision to build the world’s leading customer engagement platform. “Understanding customer data is key to achieving this vision,” as highlighted in the presentation. Essentially, what Segment can bring to Twilio is the comprehensive single view of a customer. Segment’s unique data infrastructure will be able to empower Twilio’s customer communications platform, so that we no longer need to suffer from the broken customer engagement process because of the lack of customer insights. A customer would no longer have to waste hours to be pushed back and forth between different departments from the merchant end and to repeatedly describe the customer’s purchase or service history with the merchant. On the other hand, the merchant benefits from better engagement insights with the customer so that it can be more efficient in targeted sales and marketing, offering a more personalized and impactful customer experience. “The one thing that’s always been missing from Twilio as we’ve been building up this customer engagement platform is understanding of the end-users themselves,” said Twilio co-founder and CEO Jeff Lawson. “We power the communications, but we don’t actually know who the customers are.” Meanwhile, the acquisition is a brilliant strategic move to take the advantage of Twilio’s recently hyped market cap. The COVID19 crisis has driven the valuation of a lot of SaaS companies up through the roof, including Twilio, whose stock price has grown more than 3X since the breakout of the pandemic. Whether the recent SaaS valuation hype is a bubble or anchored by long-term vision, Twilio is definitely smart to acquire strategic assets with its highly-valued stocks. As I was discussing the similar valuation hype in Fintech in my previous post, Twilio’s example showcased the optimal strategy in the current situation. Strategic Advantages and Potentials The strategic thinking of Twilio’s vision, as described by its CEO Jeff Lawson, sounds a lot like how direct-to-consumer (DTC) disrupted the traditional sales channel structures. In the past, brands rely on wholesale brokers or regional agency-representatives, who power sales and marketing, but brands don’t know who the end-customers are. With the data brought by Ecommerce, individual brands now have much better insights on their customers in terms of their tastes, preferences, and personalities, which can help better build out the brand image. Hence, we saw a group of strong DTC brands such as Warby Parker, Bonobos, Allbirds, and Peloton. Even the big players like Nike are putting a high priority on building out their own DTC-style membership to better understand and reach their shoppers. The rise of Ecommerce later caused the rise of Fintech, as Ecommerce platforms and individual DTC brands alike were looking for better payment experiences on desktop and mobile ends. Therefore, the mega-platforms such as eBay, Amazon, and Alibaba have built out in-house Fintech functions — some later grew too big and thus had to be spun off such as PayPal and Ant Group, others have formed strong partnerships with now fintech powerhouses, such as Shopify with Stripe, eBay and BigCommerce with Adyen, and (arguably) Weebly acquired by Square. Beyond just processing payments, Fintech companies are also powerful data sources for Ecommerce companies to better analyze their shoppers so that they can iterate on their marketing and sales strategies. However, so far, most of the innovation around Ecommerce and Fintech has only centered around either the part (marketing) or the part (payment), but not much has been done on the part, or shopper lifecycle part. And this could be Twilio’s strategic advantage. pre-sales at-sales post-sales For any brand’s financial success, LTV is the ultimate topline, and CAC is like the necessary evil. Better efficiency in the and processes can definitely help optimize CAC by lower marketing costs and minimize involuntary churn (caused by clunky payment process). There are enough service providers or partners where any brand can find great actionable insights. pre-sales at-sales Nonetheless, in terms of handling existing customer engagement, or the part, most still outsource it to call-centers who treat their valued customers badly, or some better ones start using Twilio and MessageBird but lack good data and insights to effectively maximize LTV. Therefore, equipped with the customer data infrastructure from Segment, the new Twilio has the potential to be the ultimate LTV engine for brands. post-sales Opportunities Ahead The only part missing for Twilio now is a Fintech arm, so that it can move beyond its strategic stronghold of to . As for , much of Segment’s data infrastructure can already help improve Twilio’s product offering in marketing, so what Twilio really needs now is a Fintech product to close the whole sales loop and customer lifecycle. post-sales at-sales pre-sales Similarly, for MessageBird to gain an upper-hand, the newly raised $200 million could be partially used to seek out a Fintech acquisition target, although most of the incumbent ones have grown above affordable price range. On the other hand, as some payment Fintech companies have explored the idea of leveraging financial data (at-sales) to power more efficient marketing (pre-sales), it is also likely that those who benefited from the recent valuation surge to acquire a customer engagement platform (post-sales) similar to Twilio or MessageBird. Adyen is definitely closer to MessageBird as they are both headquartered in Amsterdam, but Adyen strongly believes in organic growth and has never acquired a company in its almost 14 years of life. Twilio’s sheer size makes it a formidable acquisition target for any payment company, even for PayPal or Ant Group. Whatever the potential deal might look like or whoever it might be between, one thing we know for certain is that those who have benefited from the COVID-driven valuation surge need to take advantage of the opportunity to transform the buzz into long-term strategic value.

Why Did Twilio Acquire Segment for $3.2 Billion? To Better Understand End User Data

In the " article, I documented the foundation for a new SaaS solution that I am building (initially for my sister-in-law) — utilizing the Heroku ecosystem. At the end of that article, I had planned to write about the core technologies (Spring Boot, Angular 9, ClearDB, Okta, GitLab and Heroku) in place, as we raced for the 1.0.0 release of the solution. "Using Heroku to Quickly Build a Multi-Tenant SaaS Product However, things have been moving fast around here, and I largely attribute the speed of development and end-user adoption to everything that Heroku brings to the table for this service. As I have noted before, using Heroku as the destination for my service and GitLab's built-in CI/CD pipelines — updates that are merged from a feature branch into the master branch of the client or service are automatically deployed into production (Heroku) without any further intervention. Instead of starting the 1.0.1 release, the project is actually finishing up the 1.0.3 release.  Below is an updated feature map: Progress Via Screenshots Since using Spring JPA to create the initial schema, which it did without any issues, I have been keeping the fitness.sql up to date manually as model updates have been required.  Using IntelliJ IDEA and built in database tooling (including yFiles), I was able to quickly create the following diagram of the current MySQL/ClearDB database structure: As noted in the prior article, everything ties back to the ID of the tenant (or fitness trainer) - which is also enforced in the base JPA Specifications employed at the service level. These changes, along with screens for Client configuration and Workout configuration, allowed the Session screen to be introduced: The Sessions (which is an instance of a workout and at least one client) are presented in an optional calendar view to give the trainer a view which is easy to comprehend at a glance: In the example above, there is only one event scheduled - since the screen shot is from my test account in the production instance of the SaaS solution. There is also a training-mode version of the Session screen, which is mainly a read-only adaptation and consolidates data for quick reference. The icons on this screen are still active, so that that trainer can not only check-in clients, but also provide session information (score and comments) too: Along the Way ... Twilio Was Discovered One of items which was slated for the 1.0.4 release was referred to as Client Check-In.  We soon realized the having a mechanism for the trainer to communicate with the clients was an important aspect, which needed to be handled next. Below are the requirements that were employed for this feature: send reminders to clients ~24 hours before their scheduled session send a workout summary after their workout resend a reminder for a session allow trainer to send a broadcast text message (e,g, "I am going to be on vacation") provide a link to allow client to confirm/cancel their session (planned for a future article) Since the concept of a mobile client is beyond the current feature roadmap, I needed to find a solution that would work with most clients. Knowing that each client was communicating with my sister-in-law via a mobile device, I decided to use SMS (or text messages) to provide a lightweight client for the application. It did not take long to settle on Twilio — especially since two colleagues ( and ) who broadcast on Twitch had been participating in Twilio's " " awesome learning experience. In fact, I would not be surprised if both still have videos on their channels of them playing the "TwilioQuest" game. roberttables blendedsoftware TwilioQuest Twilio provides the functionality I need with a robust API. I was able to quickly set up a trial account (which communicates only with mobile numbers that are added to the system), but that was enough for me to validate the functionality. Preparing for Twilio The first step is to create a new account in Twilio by visiting the following URL: https://www.twilio.com/try-twilio Which should direct first-time users to a screen similar to what is shown below: Once everything is setup, the Twilio dashboard will appear as shown below: The Account SSID and Auth Tokens are accessible via this screen. I wanted to configure Twilio programmatically in mode project, so that using my production instance of Twilio was based upon environment variables passed in from Heroku. Below is a list of the attributes that I am managing in my API: jvc:
sms:
   twilio:
     enabled: ${TWILIO_ENABLED}
     account-sid: ${TWILIO_ACCOUNT_SID}
     auth-token: ${TWILIO_AUTH_TOKEN}
     phone-number: ${TWILIO_PHONE_NUMBER}
     enable-reply: ${TWILIO_ENABLE_REPLY}
     reply-host: ${TWILIO_REPLY_HOST}
     trial: ${TWILIO_IS_TRIAL}
     trial-phone-number: ${TWILIO_TRIAL_PHONE_NUMBER}
     cron-schedule-reminder: cron-schedule-summary: "0 17 * * * ?" "0 27 * * * ?" The README.md for my API repository provides the documentation details for the environment-specific values: ${TWILIO_ENABLED} - Twilio (SMS) enabled [jvc.sms.twilio.enabled] (set to order to disable SMS)
${TWILIO_ACCOUNT_SID} - Twilio (SMS) account SID [jvc.sms.twilio.account-sid] (leave unset to disable SMS, recommended non-Production environments)
${TWILIO_AUTH_TOKEN} - Twilio (SMS) auth token [jvc.sms.twilio.auth-token]  (leave unset to disable SMS, recommended non-Production environments)
${TWILIO_PHONE_NUMBER} - Twilio (SMS) phone number to use sending messages [jvc.sms.twilio.phone-number]
${TWILIO_ENABLE_REPLY} - Twilio (SMS) enablement reply functionality [jvc.sms.twilio.enable-reply]
${TWILIO_REPLY_HOST} - Twilio (SMS) reply host URL ( Angular client) to use when reply functionality is enabled [jvc.sms.twilio.reply-host] (value should not end a /)
${TWILIO_IS_TRIAL} - Twilio (SMS) trial indicator [jvc.sms.twilio.trial] (use non-Production instances)
${TWILIO_TRIAL_PHONE_NUMBER} - Twilio (SMS) trial phone number to send to [jvc.sms.twilio.trial-phone-number] (use non-Production instances) false in for for for of of with for for The cron based items determine the schedule of the session reminder and session summary jobs which are running in each environment (if enabled). Within Spring Boot, a simple TwilioConfigurationProperties class was created: @Data
@Configuration( )
@ConfigurationProperties( )
public {
   private boolean enabled;
   private accountSid;
   private authToken;
   private phoneNumber;
   private boolean enableReply;
   private replyHost;
   private boolean trial;
   private trialPhoneNumber;
   private cronScheduleReminder;
   private cronScheduleSummary;
} "twilioConfigurationProperties" "jvc.sms.twilio" class TwilioConfigurationProperties String String String String String String String With these values set up, I can use the Run/Debug dialog in IntelliJ IDEA to pass in the expected values: In Heroku, these values are set up in the environment: Keep in mind, the Heroku values are different, because that is actually the production instance that I have running. The Sms Service Within the SmsService, the following public methods are available: @RequiredArgsConstructor
@Slf4j
@Service
@Transactional
public {
 @Resource(name = )
 private UserData userData;
 private final AttendeeRepository attendeeRepository;
 private final MotivationalQuoteRepository motivationalQuoteRepository;
 private final SessionRepository sessionRepository;
 private final TwilioConfigurationProperties twilioConfigurationProperties;
 public sendGroupMessage(GroupSmsMessage groupSmsMessage) throws FitnessException { }
 public sendSimpleMessage(SimpleSmsMessage simpleSmsMessage) { }
 public resendSingleReminder(long attendeeId) { }
 @Scheduled(cron = )
 public sendSmsMessages() { }
 @Scheduled(cron = )
 public sendSmsSummaryMessages() { }
} class SmsService "requestScopeUserData" void // allows a trainer to send a SMS message to a select group of customers void // allows the system to send a single SMS message, which is used to send a message to the trainer each time a client confirms or cancels their session void // allows the trainer to render the session reminder. "${jvc.sms.twilio.cron-schedule-reminder}" void // allows the trainer to render the session reminder. "${jvc.sms.twilio.cron-schedule-summary}" void // ran hourly, provides a workout summary (including a random fitness quote) to the customer - which can include: // -  the score from the session // - any comments provided by the trainer // - a random fitness quote These methods are called either by a scheduled task or triggered from a request from the Angular client. The next section presents and example of how the Angular client interacts with the Spring Boot service in order to communicate with the Twilio service. Example - Sending a Group Message Sending a Group Message is initiated by the Angular client.  An example is shown below: The request is passed to the following controller in Spring Boot: @PostMapping(value = )
public ResponseEntity<Void> postSession(@RequestBody GroupSmsMessage groupSmsMessage) { {
       smsService.sendGroupMessage(groupSmsMessage); ResponseEntity<>(HttpStatus.CREATED);
   } (FitnessException e) {
       log.error(e.getMessage()); ResponseEntity<>(HttpStatus.BAD_REQUEST);
   }
} "/sms" try return new catch return new The GroupSmsMessage object has the following properties: @Data
public {
   private messageBody;
   private List<ClientDto> distributionList = ArrayList<>();
} class GroupSmsMessage String new The controller then calls the following method: public sendGroupMessage(GroupSmsMessage groupSmsMessage) throws FitnessException {
   log.info( , groupSmsMessage); (CollectionUtils.isEmpty(groupSmsMessage.getDistributionList())) { FitnessException(FitnessException.ENTITIES_MISSING, );
   } (StringUtils.isEmpty(groupSmsMessage.getMessageBody())) { FitnessException(FitnessException.ENTITIES_MISSING, );
   } (!smsEnabled()) { FitnessException(FitnessException.UNAUTHORIZED, );
   }
   Twilio.init(twilioConfigurationProperties.getAccountSid(), twilioConfigurationProperties.getAuthToken());
   log.info( );
   logSmsInformation();
   int successCount = ;
   int errorCount = ; (ClientDto clientDto : groupSmsMessage.getDistributionList()) {
       Message message = Message.creator( PhoneNumber(twilioConfigurationProperties.isTrial() ? twilioConfigurationProperties.getTrialPhoneNumber() : clientDto.getPersonDto().getPhoneNumber()), PhoneNumber(twilioConfigurationProperties.getPhoneNumber()),
         groupSmsMessage.getMessageBody())
         .create(); (message.getErrorCode() == && StringUtils.isEmpty(message.getErrorMessage())) {
           successCount++;
       } {
           errorCount++;
           log.error( + message.getErrorCode() + +  message.getErrorMessage() + + groupSmsMessage.getMessageBody());
       }
   }
   log.info( , successCount, errorCount);
   log.info( );
} void "sendGroupMessage(groupSmsMessage={})" if throw new "Could not send group SMS message to an empty distribution list." if throw new "Could not send group SMS message with an empty message body." if throw new "sendGroupMessage() SMS is NOT enabled to run on this instance" "sendGroupMessage() started" 0 0 for new new if null else "Error #" "(" ") occurred sending smsMessage=" "Successfully sent {} SMS messages ({} errors)" "sendGroupMessage() completed" In the code above, after checking for elements which can yield a Fitness exception, the Twilio.init() method is called.  Thereafter, a Message is created and the logic has been included to function in production and non-production environments.  This basically ties to using the provided trial phone number when not running in production.  Everything else is straight forward and pass the data received by the Angular client directly to the target distribution list. Conclusion The goal of this article was to outline some client communication needs for the SaaS solution I am building.  Thereafter, I provided an example of how easy it is to create a Twilio instance and integrate the solution into my Spring Boot service and Angular client.  Using Spring Boot and an Angular client, I was able to quickly and easily get SMS communication configured in use within a matter of hours.  In my view, Twilio provides an awesome compliment to the services I am using with Heroku. From a cost perspective, my sister-in-law has been using the SMS functionality for right at two months now and I just added more money into my production Twilio account two days ago.  At this point, the total usage has been right at $10 a month - which is far less than I expected to use. In the next article, I plan to discuss how Twilio was used to send the session reminder, providing a mechanism where clients can confirm or cancel their attendance to this session.  I had initially planned to include everything in one article, but I felt it would be better to create an article dedicated to this functionality.  In another future article, I plan to dive into how an end-user's reply to the original (Twilio) SMS can be redirected to the actual trainer for that customer. Exciting articles planned, for sure! (Published with the kind permission of John Vester from the original at DZone )

How To Easily Integrate Twilio Into Your SaaS Startup [Part 2]

Today's post serves the purpose of explaining , the very feature which made it possible to receive the call audio while still being able to send audio for playback . Twilio's recent bidirectional streaming feature asynchronously This was not possible before, when communication had to be unidirectional: either you could receive the voice audio but could not respond to it, or you could send audio to the call but not get anything back. Let's get right into the tutorial. One needs to understand three things if he or she hopes to use Twilio in conjunction with her own Voice Assistant (abbreviated VA). 1. How the backend of the VA receives the user's voice and returns audio responses (HTTP or Websocket? Streaming or one-off? In which audio format?) 2. How to serve calls using a node.js server (How can a phone call to a twilio number perform a request to a Node server?) 3. How to open and use a bidirectional communication channel between node.js code and the actual phone call (Through which protocol?) We will tackle these questions one at a time. But first, let's see the prerequisites: * Some experience with node.js HTTP servers and websockets * A public server with an open port * SSL keys for the domain of the server * A Twilio account with a Twilio number, either toll-free or house number Now, with that said, let's move on to the tutorial! The VA backend Most Voice Assistants work in turns. That is, they receive a user utterance (a user phrase), they generate the answer as voice audio, they send it back to the user and then wait for the next utterance, which starts the next dialogue turn. The user cannot speak again before getting the response from the VA. So, we mainly have two data flows, the voice data from the client to the VA (flow A) and the synthesized voice response from the VA (flow B). This turn-taking model is illustrated in the following graphic: The next thing to know about our presupposed VA model, is that flow A is an audio whereas flow B is sent as a single message. This follows from the way audio is generated: user voice audio is produced sequentially and can thus be streamed. On the other hand, the VA's response synthesized voice is generated totally, not partially - the first second is available as soon as the whole message is available. stream, Finally, turn taking is managed using two signals. The first one, is sent by the client at the beginning of the user's turn (start of flow A). The other signal is It is sent by the VA backend as soon as it recognizes the end of single phrase in the incoming audio (alternatively this can be controlled by the client as well). The SINGLE_UTTERANCE_END signal is sent to the client to prevent it from sending further audio. The process can be seen in detail in the flow diagram below: RESTART_COMMUNICATION, SINGLE_UTTERANCE_END. Audio encodings, what a mess! When I first tried to connect our team's VA to Twilio, one of the first things I checked was Twilio's audio format. I had hoped for an option for wav or mp3 encodings. Alas! The only supported format is that mysterious mulaw (or u-law or μ-law) encoding, which I learned that is aimed specifically for speech audio. I also learned that it is not widely used outside of telephony; chances are that in your system you won't have mulaw, which means that you will have to do some audio conversion. Although this might take a significant amount of work, I will not cover this part. I will only mention that for python, you can convert to by using the module in this code snippet. wav mulaw audioop wave.open(wavfile, ) wav: 
 # load frames 
 raw_wav= wav.readframes(wav.getnframes()) 
 # downsample 
 raw_wav_8khz, st = audioop.ratecv(raw_wav, , , , ,None) 
 # to explain the above: 
 # : sample depth bytes 
 # : number channels 
 # : samplerate 
 # : desired samplerate 
 
 # convert to mulaw 
 raw_ulaw = audioop.lin2ulaw(raw_wav_8khz,wav.getsampwidth()) with "rb" as 2 1 24000 8000 2 in 1 of 24000 8000 Twilio node.js server From this chapter onwards, we will be discussing the Twilio server itself. To insert programming logic into your voice call, you have to use a node server. Below you can see the project structure of the tutorial. This is a node project and the server is its entry point. There are some xml files with the server's TwiML resposes (don't worry if you don't know what that is) in the templates directory. Also, there is a keys folder, with the server HTTPS keys. Last, but not least, the npm dependencies are: * httpdispatcher * websocket If you are experienced with node.js, you can skip to the last part of the article ("putting it all together"). Taking it one step at a time: part 1 - TwiML without Streams Before understanding what the node server does, let's create a simple Twilio server and connect it to a Twilio number in a baby example. This baby example will later grow into our fully functional Twilio front-end for our VA! Every node.js server for Twilio has an endpoint returning some TwiML. In our case, the server will have an endpoint on path accepting HTTP POST, responding with the the contents of file , i.e.: /twiml templates/babyapp.xml This is your Voice Assistant speaking! < > Response < > Say </ > Say </ > Response What does the TwiML do? Simply it informs Twilio on how to respond to the phone call. In this case, it will merely say "This is your Voice Assistant speaking!" with a synthesized voice, before hanging up. This is the essential file for Twilio. So, before you continue, make sure you have this file. Also, you need to make sure the dependencies are installed (as mentioned above, and ). Finally, it is necessary to spin up a server to serve this TwiML. The code responsible for sharing the TwiML is as follows: httpdispatcher websocket Store the code in . The server's work is done in 's method: is read and then sent back to the client as HTTP POST reponse body. Now you have to install the dependencies (npm-install) and run the server: twilio_server.js dispatcher onPost templates/babyapp.xml node twilio_server.js Now you should be able to access the TwiML in using curl: app.xml curl -d -X https://yourhost:1312/twiml This should return: This is your Voice Assistant speaking! < > Response < > Say </ > Say </ > Response To make this work one final step is needed. First, install the twilio-cli and setup your twilio credentials. Then, connect the endpoint of the server you just made with your Twilio number: twilio phone-numbers:update +111234567890 --voice-url http://your.host:1314/twiml Now, if you have configured your Twilio number correctly, you should be able to call it and listen to the message you have specified with the tag! <Say> Taking it one step at a time: part 2 - pipe them messages! Now it's time to change the TwiML to allow bidirectional communication with the call: This is your Voice Assistant speaking! <?xml version="1.0" encoding="UTF-8" ?> < > Response < > Say </ > Say < > Connect < = > Stream url "wss:your.host:1314/socket" </ > Stream </ > Connect </ > Response Save the new TwiML in a new file named , inside the dir. app.xml templates What is this new sorcery? In simple terms, is used to set the websocket to which the call will connect and is used to make this websocket bidirectional. The latter tag is the one of the additions made in July 2020, which made it easy to use Twilio with VA's. <Stream> <Connect> As you can see, the websocket address has the same host and port as before. The reason for this is that we will handle this connection through the same server that we use for serving the TwiML. We will call this websocket the . You need one more, one for communicating with the VA. We will call this websocket the . In the schema below, note the role of the the node server in the middle: Twilio websocket VA websocket In essence, the Twilio server is just middleware between the Twilio cloud service (which sends voice audio and receives what should be played back to the human on the phone) and our VA. It is, at the same time, a server for twilio to connect to, and a VA client. Both websockets are mostly described by their message handler; they do not perform any special actions when closed, neither do they do something special when opened, apart from binding the message handlers. Let's jump right into the code that handles incoming Twilio messages: Twilio's messages are named events, and there are 5 types of events: , , and . They are described in detail in . and events are just one-off events sent at the beginning and the ending of the call. connected start, media mark close Twilio's docs Connected close The event only occurs once too. When using the tag, Τwilio sends voice audio in base64 encoded chunks, proceeded by a single message. This message is handy for getting the of the call (a unique ID used when sending stuff to Twilio) and, of course, it signifies the start of the voice stream. start <Stream> start start streamSID This is a good time to start the communication with the VA using the signal. Also it is necessary to turn the attribute to . This attribute has two values: or . Mode is during flow A is being sent, while mode is for the rest of the time. "Waiting" is not a really good name though, as there is stuff going on in the waiting phase too, as we will see in the next section. RESTART_COMMUNICATION mode "recording" "recording" "waiting" "recording" "waiting" The event is sent many times: it contains chunks of , recorded from the user's phone. This kind of message should be sent to the VA. Also, any necessary preprocessing should happen here. e.g changing the encoding. media streaming voice audio Lastly, the event carries a message. In Twilio it is often used for notifications. In this case, it is received from the Twilio call when playback of a VA's response has ended (if you're feeling confused, things will clear out when you read the next section). Here, a new conversation turn starts - the user can speak again. Attribute is set back to and the signal is sent to the VA. mark this.mode "recording" RESTART_COMMUNICATION Messages on the VA websocket Next is the handler of the VA websocket: Similarly to the handler of the Twilio socket, this one accepts only string messages: it handles the messages we talked about before and the audio responses from the VA. The former are used to stop the recorded audio from the call from being sent to the VA. SINGLE_UTTERANCE_END The latter are prefixed with and are sent to Twilio, to be played back to the user. But this not enough - a mark message is also sent right after the audio. This step is important, because it tells Twilio to notify the server as soon as the sound clip that was just sent has been played to the user. Notice the field: its value is the same as the name in the mark message Twilio will send afterwards. _MULAW "name" Putting it all together Now it's time to unify things into one big working server. The suggested solution is to create a class named , and create an instance of this class for every incoming Twilio connection. The two websockets we already described are attributes of . The setting up of the sockets, i.e. the connection of the client to the VA and the binding of onMessage(), onOpen(), onError() etc is done in the class constructor. MediaStream MediaStream Some details of importance: 1. The tag only supports wss (the secure websocket protocol). That means that you must have an HTTPS server with the keys ready in a separate keys folder (lines 1-15). <Stream> By the way, the options object used to create the server also contains the path for the Twilio websocket endpoint provided in the TwiML. This HTTPS server will be fed into the constructor of the WebsocketServer object. The latter will listen to the endpoint specified in the TwiML (lines 16-20). 2. The code in lines 26-47 is the same as the first part, it is made for serving the TwiML inside the .xml. 3. The next part (lines 49-81) might look a bit perplexing. Essentially, it is the code that establishes the connections with Twilio and the VA. A bit more explantion is due: Everything starts when Twilio is connected to the websocket endpoint. This causes the creation of a MediaStream object, with the connection object as an argument. The code in the constructor ensures that the processing of messages from Twilio will start the websocket with the VA has been opened. after This is achieved by binding the function to the onConnected event, in line 61: when the connection with the VA is complete, then it is safe to bind the message handlers to the websocket connections. prepareWebsockets() That's all for today. Let me know how it went, and feel free to ask any questions in the comments section. Happy coding!

Twilio: How to Connect with Existing Voice Assistant 

Google Call Screen for Android helps users to combat robocalls. Apple has its own feature in iOS 13 that allows users to send unknown callers to voicemail. While this feature is nice there is one glaring issue. The problem is that sometimes the user is expecting a callback and does not want to send the caller straight to voicemail, such as a call from a recruiter, delivery driver, Uber/Lyft driver and etc. To help solve this issue, I have created my own call screen solution using Twilio Studio and Node-Red. Demo What do you need? Node-Red Instance Twilio Account Twilio Number that has the capability to send and receive SMS, and to make calls Download this beep audio file — http://soundbible.com/mp3/Short%20Beep%20Tone-SoundBible.com-1937840853.mp3 Optional: Sign up Watson Natural Language Understanding if you want to capture the caller’s name and the company they represent from the call message. Need to add in your Node-Red Watson Node Getting Started Twilio Friendly Name = Transfer
//This will be use to transfer the call to you when you accept > <?xml version="1.0" encoding="UTF-8"?> < > Response < = > Dial callerId "<<YOUR TWILIO NUMBER>>" < > Number << > YOUR PERSONAL PHONE NUMBER </ > Number </ > Dial </ > Response Friendly Name = Failed Call
//Used for if a called has fail or you didn't pick up Sorry, > is currently busy right now. >’ll try to get back to you as soon > is available. Good bye. <?xml version="1.0" encoding="UTF-8"?> < > Response < > Say << > YOUR NAME << / > SHE HE << / > SHE HE </ > Say < /> Hangup </ > Response Create two TwiML Bins, look at the code block above. Keep track of the URLs of the bins once you save it. Make sure you format your phone numbers to E.164 Upload the beep file that you download by going to Assets in your Twilio console and dragging and dropping the file. Take a note of the asset URL Go to Twilio Studio, create a new flow, give it a name and click on Import from JSON. Then copy and paste the JSON from this link In the flow, there is a widget call setVariables. Please set your name, your Node-Red URL, your beep asset URL, and your personal phone as values and save the flow. Note: Example of Node-Red URL value, http://testing.ngrok.io Go to your Twilio phone number and set both the incoming voice and messaging to call your new studio flow Getting Started on Node-Red In your Node-Red dashboard click on the hamburger icon that is at the top right of the page and select Import, then copy and paste or import this . If you want to use Watson Natural Language Understanding, import this . Make sure you have the install before importing the JSON JSON Watson JSON Watson Nodes Click on the node label Set All Variables and set your Twilio Account Sid, Auth Token, and TwiML Bins URLs (Optional) If you signed up Watson Natural Language Understanding, go to the Watson Natural Language Understanding node and fill in your credentials. On your Twilio studio flow go to setVariables widget and set usingWatsonNLU variable to true On the top right of the page click Deploy and you should be ready now! How to Demo? Just add the Twilio number as a contact on your phone and use a second phone to call the Twilio number. On the call, you should be getting a greeting message and asked to state your purpose after the beep. Once you replied, you will be placed on hold. On your main phone, you should be getting a message from Twilio that has vCard and a text message that looks like the example below Phone call :+ Message: This is a dummy message
To accept the call, reply back on the following words: Accept, Yes, Sure, Connect

Otherwise ignore message. from 12345678912 with of this To accept the call, replied to the text message the word “accept” and Twilio will connect your main phone to your second phone. If you were able to connect, Success! You have done it! If you want to don’t want to accept the call, just leave it and the caller should be getting an ending message within a 1 min or so. What if I want the person to connect with me ASAP? After the beep, if the user press 1 on the keypad they’ll be connected to your main phone number. Downside? You won’t know their caller phone number. Now what? Instead of giving out your main phone number when signing up for services, while handing out your resume, creating a profile, and etc, you can give your Twilio number and keep your main phone number private. Limitations? The biggest limitation is that some services that you signed up will require you to verify your phone number by using a passcode sent by text. There are ways to to your main phone number from the Twilio number, but sometimes you won’t get any passcode. I think the reason why is because some companies have a list of numbers they will not send a text to because that number belongs to a company, such as Twilio, and not to an individual person. forward the text messages Customization Want to change how you accept a call? Go to setVariables widget and change acceptCode values. You can create your own acceptCode, just make sure each word is separate by a comma Want different hold music? Go to sendCallertoQueue widget and replace the Hold Music TwiML URL field with your URL of choice. You can find a great library here Troubleshooting Watson NLU not work? Make sure you either fill in your username and password or your API key in the Watson NLU node. Check that you're using the correct Service Endpoint. Check on the Twilio Studio setVariables that usingWatsonNLU is set to true Helpful Links Other beeps — http://soundbible.com/tags-beep.html This article was previously published behind a paywall at: https://medium.com/@wilsonwong13/create-your-own-google-call-screen-using-twilio-and-ibm-node-red-ca01d3fa34f0?source=friends_link&sk=7aae432bfcf600ab083ae8c1d542c791

How to Create Your Own Google Call Screen Using Twilio

We live in an era of collaboration and teamwork. Meaning that even the most straightforward task in this day and age (think ordering lunch, for example) is often brought before a committee vote. Thankfully, ours is also an era of great technological achievement, and there is perhaps no better way to arrive at a consensus than through the use of polling and surveys. Today we are going to see how we can use to deploy a quick and easy-to-use polling app that uses your number to dispatch SMS messages to your group, and then logs their replies in one convenient Base. Build on Standard Library Twilio Airtable What our Airtable Base will look like upon completion! What You’ll Need Beforehand - 1x Airtable account — https://www.airtable.com - 1x Twilio account — https://www.twilio.com - 1x Standard Library Account — https://www.stdlib.com Step 1: Setting Up Airtable The first thing that we want to do is set up our Airtable Base so that it is ready to begin receiving data. If you are a new user, sign up for an account by , and then You should see a Base that looks like the above screenshot, but without the polarizing question already populated. As you can see, our base has three tables, two of which require some input from you, and one that will be entirely populated by Standard Library. Let’s take a closer look at what each of these tables is responsible for tracking. visiting this link click here to add our Base template to your Airtable Workspace. —This table tracks your current and past questions. Questions go in column one, and the other columns will be handled by our application Questions — This will be a table of individuals who are a part of your group. The only required field here is the phone number( + + 14155309876 for example). The name field is optional Contacts country code area code phone number. — This table will be entirely populated by our application. It stores the returned text message, along with who sent the reply, and which question the reply was meant for Replies For the sake of this tutorial, you will need to add at least one number to the contacts table (I would recommend testing with your own cell phone number) and one question to the questions table (feel free to continue the GOAT debate if you would like). Now that the Base is set up, let’s start our workflow on Standard Library! Step 2: Build Your Workflow on Standard Library If you haven’t done so yet, get yourself a (it’s free!) and head on over to to begin building out your workflow. For this project we will want to trigger our survey by visiting a URL, so underneath choose as your event, and proceed to put in the following options: Standard Library account https://build.stdlib.com When This Event Happens HTTP or Webhook When This Event Happens HTTP or Webhook → HTTP Request is sent to Project Endpoint → send-survey This Workflow Will be Triggered Airtable → Select Rows by querying a Base Airtable → Select Rows by querying a Base Twilio → Send a message When you have finished, your screen should look like this: You are now ready to click Create Workflow! Step 3: Link Your Resources The next order of business is linking your Twilio and Airtable accounts with an Identity on Standard Library. For those unfamiliar, linking a resource on Standard Library allows you to securely set up your accounts once, and then makes them available to you across all of your workflows. Let’s start by linking an Airtable account and choosing a Base. Click on the button to be presented with the following screen: Link Resource If you have previously linked Airtable Bases, they will appear here. If this is your first time linking your Airtable account, click the button and input a display name on the following screen. You will also need to and include that here as well. It should look something like this: Add New Account retrieve your API key from Airtable Click on and proceed to choose your Base! Finish Now you will arrive at a screen presenting you with all of your Bases. Choose the one that you added earlier from our template called and then click Twilio Survey, Finish [Link Base]. An inventory of all your Airtable Bases. That takes care of Airtable, so now you can proceed to link a Twilio number to your project. The process will look very similar to the Airtable process at first, and you will see the same pop-up screen asking you to or , depending on whether or not you have used Twilio on Standard Library in the past. If you see a number that you would like to use for this project here, click on the green button and move on to the next step. Add New Account Link New Resource Choose If you do not have a number linked yet, proceed to click either or After the loading screen finishes, you should see something like the following: Add New Account Link New Resource. Twilio numbers purchased on Standard Library will show up here. If you have numbers that you have purchased on Twilio outside of Standard Library, you will notice that they are absent from this screen. This is the result how Twilio Connect apps work. To read more about Twilio Connect apps and sub-accounts, Note: click here. You can now either select a previously linked number that you have purchased through Standard Library, or purchase a new number to use for this project. Once you have done that, click on the blue button, and you will see the following: Finish [Link Phone Number] With your you can now click on button. Identity Generated Next Part 4: Set Up Your Workflow The following screen is where we will configure the workflow APIs that we selected earlier. We will start with our initial query. Where the interface asks for a ‘ ’ fill in ‘ ’. Leave all other fields blank, since we want the query to return all of the numbers in the table. Your window should now look like this: table Contacts Our first query to grab all of the numbers in our table. Contacts Now click on the six dots next to the second row of our workflow, that says → You will see a new blank query. Fill it in with the following: Airtable Select Rows by querying a Base. table → Questions where → key: → select: wasSent is NULL Click on the next to blue plus sign Add a new AND clause to this KeyQL Query operation In this new box, enter: where → key: → select: → type in: Status is equal to Pending Searching for an eligible question. Questions Next, click on the six dots to the left of at the top of our dialog box. We have the option to enter up to four values here, but we only need two. In the field enter: Twilio to: ${result.step1.selectQueryResult.rows[ ].fields.Number} 0 Then, in the field enter: body: ${result.step2.selectQueryResult.rows[ ].fields.Question} 0 Set up the Twilio workflow like this. Click on the green button at the bottom of the dialog box and you should receive a text with the question that you entered into Airtable. If you did, then it is working! Run with Test Event While it is possible to do most of what we need to do in the Build interface, we will need to make some customizations to our code to store the results of multiple queries (what if our Contacts table has more than one number?). In order to do all of these things, we will need to briefly dive under the hood of Build by switching the button to . Developer Mode On Here you have a behind the scenes look at what all your hard work has been producing. This is the code that has been generated by our workflow. Replace everything inside of here with the following snippet. result = {}; .log( );

result.selectContacts = lib.airtable.query[ ].select({ : }); (result.selectContacts.rows.length === ) { { : };
} .log( );

result.selectQueryResult = lib.airtable.query[ ].select({ : , : [
 { : , : },
 ]
}); (result.selectQueryResult.rows.length === ) { { : };
} (result.selectQueryResult.rows[ ].fields.Question === ) { { : };
} seen = (); nums = result.selectContacts.rows.reduce( { (!seen.has(cur.fields.Number)) {
 acc.push(cur);
 seen.add(cur.fields.Number);
 } acc;
}, []); .log( ); ( row nums) {
 result.result = lib.twilio.messages[ ].create({ : , : , : + + + , : }).catch( { .log( );
 });
}; .log( );

result.updateQueryResult = lib.airtable.query[ ].update({ : , where: [
 { : }
 ], : { : }
}); // Prepare workflow object to store API responses let // [Workflow Step 1] console `Running airtable.query[@0.3.3].select()...` await '@0.3.3' table `Contacts` if 0 return 'message' 'No contacts found. Please update your contacts table with valid contacts and try again.' // [Workflow Step 2] console `Running airtable.query[@0.3.3].select()...` await '@0.3.3' table `Questions` where wasSent__is null Status `Pending` if 0 return 'message' 'No valid questions found. Please check the questions table and try again.' else if 0 null return 'message' 'Whoops, looks like you left the question blank!' // [Workflow Step 3] let new Set let ( ) => acc, cur if return console `Running twilio.messages[@0.1.0].create()...` for let of await '@0.1.0' from null to ` ` ${row.fields. } Number body `Your friend sent you a Twilio Survey:` `\n` `\n` ` ` ${result.selectQueryResult.rows[ ].fields.Question} 0 mediaUrl null => err console `Oops, not a valid number!` // [Workflow Step 4] console `Running airtable.query[@0.3.3].update()...` await '@0.3.3' table `Questions` // required Question ` ` ${result.selectQueryResult.rows[ ].fields.Question} 0 fields wasSent true Please be aware that toggling to will cause all of your changes to be lost, so best to keep it activated until we have shipped the project. Note: Developer Mode Off The first half of this will allow us to grab 1. all of the numbers that we have included in the table, and 2. the question that we want to send from the table. Note that the criteria for selecting a question is that the column is (null), and that the column reads In the event that there are two or more questions that match this query, Contacts Questions wasSent unchecked Status Pending. only the most recently added one will be sent. This second half of this code allows us to perform the action from our linked Twilio account to every user that we have inserted into our table, and then changes the value for the question to . Now click on the green button again, and you should receive a message with your first question! Send a message Contacts wasSent true Run with Test Event Let the debate begin. If you received the text message, and if the column in your table was updated to (that is to say, the column now has a green check!), then proceed to click on the blue button. On this final page you will name your project (name it ) and then go ahead and click on the blue button. You will receive a message informing you that you are awesome. Well done! wasSent true Next twilio-survey Alright, Ship It! It is important to note before moving ahead to the next section that in order to conduct our survey going forward, . If you recall, when we began setting up our workflow we decided that would be the event that triggers these actions. Meaning that if you ever want to conduct another survey, you will need to ping the URL generated by this workflow. It will look like this: you will need to ping the URL that is being generated during this step HTTP Request is sent to Project Endpoint https: //<Your-Username>.api.stdlib.com/twilio-survey@dev/send-message/ Where <Your-Username> is replaced with your Standard Library account name. is the name of our project, and is the name of the endpoint that we set up when we determined our event. twilio-survey send-message Part 5: Storing Replies We now need some way to track replies. This will require setting up a new event in our project to insert SMS messages to our Twilio number into our Airtable Base. Navigate back into your project by clicking on the link on your project’s homepage: dev (click to manage) Find the box that enables you to add new events. It will be located just under the previous workflow that you created. You will see greyed out text that reads and Event Source When this Event happens… For this workflow, we want to choose: Twilio → sms.received Your section should now look like this: Integrations After you have clicked on set your workflow up as follows on the dialog page: [+] Add New Workflow, Airtable → Select Rows by querying a Base Airtable → Select Rows by querying a Base Airtable → Insert a row into a Base Proceed by clicking , and you should see the previously linked resources. Feel free to simply click . Here, we will once again be taking the plunge into . Toggle this to , and paste the following snippet into the editable portion of the box: Next Next Developer Mode On result = {}; .log( );

result.selectQuestion = lib.airtable.query[ ].select({ : , : [
 { : , : }
 ]
}); n = event.From.split( ); num = (n[ ]);

result.selectContact = lib.airtable.query[ ].select({ : , : [
 { : num
 }
 ]
}); contact = result.selectContact.rows[ ].id; question = result.selectQuestion.rows[ ].id;

repliesQueryResult = lib.airtable.query[ ].select({ : , : [
 { : contact, : question
 }
 ]
}); (repliesQueryResult.rows.length === ) {
 result.insertQueryResult = lib.airtable.query[ ].insert({ : , : { : , : [contact], : [question]
 }
 }); lib.twilio.messages[ ].create({ : , : , : , : });
}; // Prepare workflow object to store API responses let // [Workflow Step 1] console `Running airtable.query[@0.3.4].select()...` await '@0.3.4' table `Questions` where wasSent__is true Status__is `Pending` // [Workflow Step 2] let '+' let parseInt 1 await '@0.3.4' table `Contacts` where Number // [Workflow Step 3] let 0 let 0 await '@0.3.4' table `Replies` where Respondent__contains Question__contains if 0 await '@0.3.4' table `Replies` fields Reply ` ` ${event.Body} Respondent Question await '@0.1.0' from null to ` ` ${event.From} body `Thanks for submitting your reply! Your response has been logged.` mediaUrl null Let’s cover quickly what we are doing here: We are querying the Base to determine which question is currently active We are finding the user associated with the responding phone number We are creating a new record in the table, and linking this reply to the previously selected question and user, respectively Replies Testing this code will result in an error, however, so we need to make one change to the test event. If you click the gear icon next to the button, you will see something that looks like this: Run with Test Environment Here, we need to update our phone number. From Our workflow is attempting to find a user that has the number associated with the ‘ ’ key inside this event. Change this value ( ), to a number that is present in your table (i.e. your phone number with a preceding “+”, like so: . The “+” and the country code are required here). Leave all the other values as they are, and attempt to run the test again. If you now see the message “ ” in your table, then congrats! You’re all finished. Proceed to click on , and finally From “+15555555555” Contacts “+18155451993” Hello from Twilio! Replies Next Ship It! Only the first reply sent by each user will be acknowledged and stored. You’re All Set! That is it! Sit back and watch the replies come rolling in. As we mentioned earlier in this tutorial, ensure that there is only one question that carries a Status of with a wasSent value of , as the first question to meet both of these criteria will be the one that replies are logged to. When you feel that a question has ample replies, simply change the Status field for that question to , and then proceed to add a new question. Navigate to your URL endpoint to deliver the new question. Happy polling! Pending, true Finished Kevin Brimmerman is a Software Engineer at Standard Library. Outside of work he is an avid runner and a die-hard Chicago sports fan. Go Cubs!

How to Build a SMS Surveys App with Twilio, Airtable and Standard Library

This post is a prerequisite for an upcoming post. Here I’ll be creating a Whatsapp echo bot using Twilio and Nodejs. I’ll be making use of so as to save myself from the burden of going through the environmental setup. Repl.it Now, let’s get started 🏃‍ 🔑 Accounts and Keys First, Sign up for Twilio Once you’re done verifying your phone number, select Products > Programmable SMS and then continue to name your project. Feel free to skip steps for adding teammates — you won’t need that for now. You must now take note of some authentication keys you’ll need for building the WhatsApp bot 👇 The final step — setup your WhatsApp Sandbox — choose any number, and join your sandbox following instructions on the page. 👇 here Aaaaaand you’re done with credential setup! Don’t worry, that was the toughest part of this tutorial 😛 🚀 Getting Started So that we don’t spend too much time on setup, we’ll be using ! you can use within your browser. Head over , and click on new Repl 👇 Repl.it here Select express from the language dropdown and name your Repl appropriately (or not !!). After creating it you’ll be automatically redirected to the console. Replace the code in index.js with the following code 👇 Now start the server. You’ll get an error — Error: Cannot find module ‘twilio’ To resolve this you’ll need to add twilio module in Repl.it from packages menu on the left menu bar. Search for package there and add it. Hit Restart. An interactive browser window will open up and show default route message. Let’s go back to the , and put in a webhook URL for incoming messages. WhatsApp Sandbox We’ll be using route to receive messages sent to the bot, so we will be redirecting them to the above-shown URL (Your’s will be different, obviously !!) /incoming Add to the browser URL and save that into sandbox redirect URL. /incoming After saving the configuration in the Twilio Sandbox, you’ll need to add your phone number to sandbox participants by sending the code to the mentioned number. 👇 After adding participants try sending any message from your number to the Sandbox number and observe the Repl.it consoles log. 👇 🛠️Replying to incoming messages To create an echo bot we’ll need to send back the incoming messages. For that purpose, we’ll need to use twiml. Add the following code in /incoming route handler. const twiml = new MessagingResponse(); twiml.message(req.body.Body); res.writeHead(200, {‘Content-Type’: ‘text/xml’}); res.end(twiml.toString()); Index.js at this point will look like this. 👇 Hit Restart then and send the message again to the sandbox number. Now you’ll be able to receive the same message back from the bot. ⚡ What’s next? There you have your WhatsApp echo bot. In case you get stuck you are free to use my . Just replace Account Sid and Authentication Token with your own. Repl.it Needless to say, it can be modified to create whatever you wish to do. Ranging from notification services to Wikipedia bots. One particular scenario I’ll be sharing in a few days so do stick around.

Stories, News & Mentions about TWILIO

Twilio’s Stories on HackerNoon

Twilio's News & Mentions