how to start a conference with twilio? - node.js

Plan for my Programm: Someone is calling a Twilio Number, then I get called on my mobile. As long im not accept the call, the caller should hear music or something like that and if I pick up, a conference should start.
At the moment:
Someone is calling the number and gets in queue with music, then my mobile gets called. Sounds great yet, but when i pick up we don't get connected.
So I guess I don't get properly how Twilio conference works, may you have some advices how to get this done step by step.

Twilio developer evangelist here.
OK, you're building with Node.js and I know I've seen your code in other questions, but I'm going to start this one from scratch.
With Twilio the flow that you described should look like this.
Person calls your Twilio number
Twilio makes an HTTP request to the number's Voice Request URL (which points at your application)
Your application now needs to do two things
Call your mobile number
Put the caller into a Conference with hold music playing
First you need to decide on the name of the Conference
Then to call your number, your application needs to make a call to the Twilio REST API to initiate the call to your mobile
You need to provide a callback URL in this call that will put you into the conference too, you can do this by including the conference name as a paramater in the URL
Your application also needs to return TwiML to put the caller into the Conference, using the same conference name
Finally, when you answer the phone Twilio will make an HTTP request to the URL you provided when initiating the call
That will request your URL which should respond with TwiML to put you into the same conference call
Let's look at how we can do this in a Node.js Express application:
You need two routes, one that will receive the initial request and one that will respond to the request made when you answer your phone. Check out the code and the comments below.
var express = require("express");
var bodyParser = require("body-parser");
var twilio = require("twilio");
var app = express();
app.use(bodyParser.urlencoded({ extended: true }));
var client = twilio(YOUR_ACCOUNT_SID, YOUR_AUTH_TOKEN);
// This is the endpoint your Twilio number's Voice Request URL should point at
app.post('/calls', function(req, res, next) {
// conference name will be a random number between 0 and 10000
var conferenceName = Math.floor(Math.random() * 10000).toString();
// Create a call to your mobile and add the conference name as a parameter to
// the URL.
client.calls.create({
from: YOUR_TWILIO_NUMBER,
to: YOUR_MOBILE_NUMBER,
url: "/join_conference?id=" + conferenceName
});
// Now return TwiML to the caller to put them in the conference, using the
// same name.
var twiml = new twilio.TwimlResponse();
twiml.dial(function(node) {
node.conference(conferenceName, {
waitUrl: "http://twimlets.com/holdmusic?Bucket=com.twilio.music.rock",
startConferenceOnEnter: false
});
});
res.set('Content-Type', 'text/xml');
res.send(twiml.toString());
});
// This is the endpoint that Twilio will call when you answer the phone
app.post("/join_conference", function(req, res, next) {
var conferenceName = req.query.id;
// We return TwiML to enter the same conference
var twiml = new twilio.TwimlResponse();
twiml.dial(function(node) {
node.conference(conferenceName, {
startConferenceOnEnter: true
});
});
res.set('Content-Type', 'text/xml');
res.send(twiml.toString());
});
Let me know if this helps at all.
Update
In the latest version of the Twilio Node.js library you cannot use twilio.TwimlResponse. Instead there are individual classes for voice and messaging. In this example the line
var twiml = new twilio.TwimlResponse();
Should be updated to:
var twiml = new twilio.twiml.VoiceResponse();

I solved it by myself, you need to answer both participants with an conference, it will start automatically when the other person accepted the call
Example
resp.say({voice:'woman'}, 'Welcome to our hotline. This could take a moment, please wait.')
.dial({},function(err){
this.conference('example');
});

Related

How to use twilio and twiml to record a call and redirect the call or join someone else to the call

Hi im trying with node to receive a call, start recording the call and join someone else to the call (also tried redirect) and maintain the call recording. all this have been without success.
i tried
twiml.say('HI, Your Calling XXXXX, ');
twiml.dial("XXXXXXX");
twiml.record();
but when the dial command is used the record command doesn't work, if i comment the dial command, the call get recorded.
pleas hope you can help me find how i can record and redirect a call and while keep recording it
Twilio developer evangelist here.
Using <Record> only records one leg of a call and is mostly used for voicemail style operations.
To record inbound calls with Twilio you need to use the Call Recordings API to trigger the recording to start.
Note, you need to have upgraded your account to trigger recordings like this.
You can trigger this API call as soon as you receive the inbound webhook. You can see the documentation for the call recording resource here. If you were writing this in Node.js using Express, your route might look like this:
// Load your Account Sid and Auth Token somehow, for example, from the environment
const accountSid = process.env.TWILIO_ACCOUNT_SID;
const authToken = process.env.TWILIO_AUTH_TOKEN;
const twilio = require('twilio')
const client = twilio(accountSid, authToken);
app.post('/calls', (req, res) => {
const callSid = req.body.CallSid;
client.calls(callSid)
.recordings
.create()
.then(recording => console.log('Recording started')
.catch(err => console.error('Recording failed. ', err);
const twiml = new twilio.twiml.VoiceResponse();
const numberToDial = process.env.NUMBER_TO_DIAL;
twiml.say(`Hi, you're calling ${numberToDial}.`);
twiml.dial(numberToDial);
res.set('Content-Type', 'text/xml');
res.send(twiml.toString());
});
Let me know if that helps at all.

Twilio TWIML nodejs gather sample code control flow

I was checking this sample on twilio docs (v2.x but v3.x also is similar and my question won't be altered).
// This example uses JavaScript language features present in Node.js 6+
'use strict';
const express = require('express');
const twilio = require('twilio');
const urlencoded = require('body-parser').urlencoded;
let app = express();
// Parse incoming POST params with Express middleware
app.use(urlencoded({ extended: false }));
// Create a route that will handle Twilio webhook requests, sent as an
// HTTP POST to /voice in our application
app.post('/voice', (request, response) => {
// Use the Twilio Node.js SDK to build an XML response
let twiml = new twilio.TwimlResponse();
// Use the <Gather> verb to collect user input
twiml.gather({ numDigits: 1 }, (gatherNode) => {
gatherNode.say('For sales, press 1. For support, press 2.');
});
// If the user doesn't enter input, loop
twiml.redirect('/voice');
// Render the response as XML in reply to the webhook request
response.type('text/xml');
response.send(twiml.toString());
});
// Create an HTTP server and listen for requests on port 3000
app.listen(3000);
So here is the fragment below blocking?
twiml.gather({ numDigits: 1 }, (gatherNode) => {
gatherNode.say('For sales, press 1. For support, press 2.');
});
If yes then assuming user enters something and we then move to
twiml.redirect('/voice');
and other statements execute in sequence.
BUT if its non blocking, then /voice endpoint is called immediately and this continues in an infinite loop.
I was wondering how would the flow work.
EDIT:
The confusion seems to be caused by this comment
// If the user doesn't enter input, loop
If user enters something then also twiml.redirect('/voice') is being called. I am not sure how does that code even work properly?
Ricky from Twilio here.
This code doesn't create an infinite loop, but for a bit of a different reason than blocking vs non-blocking code. The way that you control a Twilio call flow is through TwiML, which is XML containing a set of instructions of what to do with an incoming call. The node code in your /voice route isn't handling the control flow itself, but generating XML that looks like this:
<?xml version="1.0" encoding="UTF-8"?>
<Response>
<Gather numDigits="1">
<Say>For sales, press 1. For support, press 2.</Say>
</Gather>
<Redirect>/voice</Redirect>
</Response>

Using Twilio API resources within Twilio Functions

I've nearly finished my phone system with twilio and the final part is a voicemail playback. If the call fails or is declined, the calling party can leave a message and it saves to the twilio recordings. All server side code is done in Twilio Functions.
Now I want the end party to be able to check their voicemail by dialing an extension and playing back the saved messages. Everything up to the playing back of messages is done because I can't get the recording uri from a list of recordings.
Note NodeJS is not my strong suite.
I have tried playing back all recordings with:
exports.handler = function(context, event, callback) {
const twilioClient = context.getTwilioClient();
let response = new Twilio.twiml.VoiceResponse();
twilioClient.recordings.each(recording => response.play(recording.uri));
callback(null, response);
}
But I don't the expected result (i.e. I get a 200 OK and the <Response/> xml). I have Enable ACCOUNT_SID and AUTH_TOKEN enabled in the functions configuration.
I feel like it has something to do with the callback and the request to the api being asynchronous but I couldn't find much information on the recordings docs (https://www.twilio.com/docs/api/voice/recording).
Found the documentation I was after in the automated docs (https://www.twilio.com/docs/libraries/reference/twilio-node/3.11.2/Twilio.Api.V2010.AccountContext.RecordingList.html).
client.recordings.each({
callback: function (recording) {
response.say('New Message');
const recordingSid = recording.sid;
},
done: function () {
callback(null, response);
},
});

Getting 11205 error when trying to use calls().update to transfer to conference room

I'm trying to move the inbound caller to a conference room:
//this is the endpoint for the voice webhook
app.post('/voice',(req,res)=>{
sid=req.body.CallSid;
conferenceName="test conference room";
params={'conferenceName':conferenceName};
url='https://appname.herokuapp.com/addToConference?conferenceName=test';
console.log('now updating inbound call sid '+sid);
client.calls(sid).update({
url:url,
method:'GET'
});
});
//this is the endpoint for adding a caller to a conference
app.get('/addToConference',(req,res)=>{
var conferenceName=req.query.conferenceName;
const response=new VoiceResponse();
response.say("Now connecting you to conference "+conferenceName);
dial=response.dial();
dial.conference(conferenceName);
responseTwiml=response.toString();
console.log("responseTwiml: "+responseTwiml);
res.send(responseTwiml);
});
Console logging shows that the .update() call is reached:
now updating inbound call sid 9j92f892309
But then the Twilio debugger shows an 11205 error, where the url is https://appname.herokuapp.com/voice/. The console log does not show Now connecting you to conference test, so I'm guessing the /addToConference endpoint isn't being reached. Heroku error log shows a Request timeout error.
How can I reach the endpoint and drop the inbound caller into a conference call? If it matters, I want the app to then call someone else, interact with them, and then transfer that call recipient to the conference where the inbound caller is waiting.
Twilio developer evangelist here.
There's a couple of issues here. To start with, the 11205 error is because of a timeout from the call to your /voice endpoint. The issue here is that you never return anything from the function with the res. You could fix that one by calling res.send('') at the end of that function.
However...
There is no need to do the redirect that you're doing at all. You can use the initial webhook response to both drop the caller into the conference and dial the other party. You would do this with the following code:
app.post('/voice',(req,res)=>{
conferenceName="test conference room";
url='https://appname.herokuapp.com/addToConference?conferenceName=' + conferenceName;
client.calls.create({
from: YOUR_TWILIO_NUMBER,
to: THE_OTHER_PERSON,
url: url
});
const response=new VoiceResponse();
response.say("Now connecting you to conference "+conferenceName);
dial=response.dial();
dial.conference(conferenceName);
responseTwiml=response.toString();
res.set('Content-Type': 'text/xml');
res.send(responseTwiml);
});
For this you will still need the /addToConference endpoint which just adds the other caller to the conference, which would look like this:
app.get('/addToConference',(req,res)=>{
var conferenceName=req.query.conferenceName;
const response=new VoiceResponse();
response.say("Now connecting you to conference "+conferenceName);
dial=response.dial();
dial.conference(conferenceName);
responseTwiml=response.toString();
console.log("responseTwiml: "+responseTwiml);
res.send(responseTwiml);
});
You could also redirect the caller in the way you wanted to do in the first place, but instead of modifying the call with the REST API you would use the TwiML <Redirect> verb. That would look like this:
app.post('/voice',(req,res)=>{
conferenceName="test conference room";
url='https://appname.herokuapp.com/addToConference?conferenceName=' + conferenceName;
client.calls.create({
from: YOUR_TWILIO_NUMBER,
to: THE_OTHER_PERSON,
url: url
});
const response=new VoiceResponse();
response.redirect(url);
responseTwiml=response.toString();
res.set('Content-Type': 'text/xml');
res.send(responseTwiml);
});
Let me know if that helps at all.

Access transcriptionText from twilio

I want to access the transcription text that has been generated by transcribe in my Twilio account under transcriptions as I want to compare user recorded response as text
twiml.say('Hi there! Please speak your response after the beep,-Get ready!')
.record({
transcribe:true,
timeout:5,
maxLength:30,
transcribeCallback:'/recording',
action:'/recording'
});
app.post('/recording', (request,response) => {
if(transcriptionText=='yes'){
twiml.say('thank you for positive response');
}
response.type('text/xml');
response.send(twiml.toString());
});
Twilio developer evangelist here.
When using transcription with <Record>, once the recording is complete the call will continue on to make a request to the action attribute synchronously. Whatever you return from the action attribute URL will control the call.
The actual transcription, however, takes a bit more time and when you get a webhook to the transcribeCallback URL it is done asynchronously, outside the context of the call. So, returning TwiML will not affect the call at all.
You will get the transcription text by inspecting the body of the request. There are plenty of parameters sent to the transcribeCallback, but the one you are looking for is the TranscriptionText. In your Node.js app, which looks like Express to me, you can get hold of it by calling request.body.TranscriptionText.
If you do want to affect the call when you receive the transcribe callback you will need to use the REST API to modify the call and redirect it to some new TwiML.
Let me know if that helps at all.
[edit]
From the comments I can see you are trying to drive a part of the call from a spoken response. The transcribeCallback URL isn't called immediately as the transcription needs to be done, so you need an action URL that you can send your caller to while you wait.
So, adjust your recording route to have different endpoints for action and transcribeCallback:
app.post("/voice", (request, response) => {
var twiml = new twilio.TwimlResponse();
twiml.say('Hi there! Please speak your response after the beep,-Get ready!')
.record({
transcribe:true,
timeout:5,
maxLength:30,
transcribeCallback:'/transcribe',
action:'/recording'
});
response.type('text/xml');
response.send(twiml.toString());
})
Then your recording endpoint will need to keep the user waiting while Twilio transcribes the text.
app.post('/recording', (request,response) => {
var twiml = new twilio.TwimlResponse();
// A message for the user
twiml.say('Please wait while we transcribe your answer.');
twiml.pause();
// Then redirect around again while we wait
twiml.redirect('/recording');
response.type('text/xml');
response.send(twiml.toString());
});
Finally, when you get the transcribe callback you can figure out the course from the transcribed text somehow and then redirect the live call into a new endpoint that carries on the call with the new information.
app.post('/transcribe', (request, response) => {
var text = request.body.TranscriptionText;
var callSid = require.body.CallSid;
// Do something with the text
var courseId = getCourseFromText(text);
var accountSid = '{{ account_sid }}'; // Your Account SID from www.twilio.com/console
var authToken = '{{ auth_token }}'; // Your Auth Token from www.twilio.com/console
var client = new twilio.RestClient(accountSid, authToken);
// Redirect the call
client.calls(callSid).update({
url: '/course?courseId=' + courseId,
method: 'POST'
}, (err, res) => {
response.sendStatus(200);
})
});

Resources