Confirm to Answer Call

Latest Legacy

When multiple calls are fired, the first person to answer gets connected and the rest of the calls are dropped. To make sure that the call is answered by a person and not by voice mail, use the confirmKey and confirmSound attributes.

The example XML here requires the call recipient to input the digit 5 after answering the call to connect.

Plivo requests the confirmSound URL using the POST HTTP method for a valid Play, Speak, or a Wait XML element. To play a message asking the recipient to input a DTMF tone to connect the call, return the second XML example.

Response

<Response>
    <Dial confirmSound="https://<yourdomain>.com/confirm_sound/" confirmKey="5">
        <Number>12025551111</Number>
        <Number>12025552222</Number>
        <Number>12025553333</Number>
    </Dial>
</Response>

Return the following XML to play a message.

<Response>
    <Speak>Enter the digit 5 to connect the call</Speak>
</Response>

Example Request

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from plivo import plivoxml

response = plivoxml.ResponseElement()
response.add(
    plivoxml.DialElement(
        confirm_key='5', confirm_sound='https://<yourdomain>.com/confirm_sound/').add(
            plivoxml.NumberElement('12025551111')).add(
                plivoxml.NumberElement('12025552222')).add(
                    plivoxml.NumberElement('12025553333')))
print(response.to_string())

# XML to play the message
play_message_response = plivoxml.ResponseElement()
play_message_response.add(
    plivoxml.SpeakElement('Enter the digit 5 to connect the call'))
print(play_message_response.to_string())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
require 'rubygems'
require 'plivo'

include Plivo::XML
include Plivo::Exceptions

begin
  response = Response.new

  params = {
      'confirmSound' => "https://<yourdomain>.com/confirm_sound/",
      'confirmKey' => "5"
  }

  dial = response.addDial(params)
  first_number = "12025551111"
  dial.addNumber(first_number)

  second_number = "12025552222"
  dial.addNumber(second_number)

  third_number = "12025553333"
  dial.addNumber(third_number)

  xml = PlivoXML.new(response)
  puts xml.to_xml
rescue PlivoXMLError => e
  puts 'Exception: ' + e.message
end

begin
  response = Response.new

  speak_body = "Enter the digit 5 to connect the call"
  response.addSpeak(speak_body)

  xml = PlivoXML.new(response)
  puts xml.to_xml
rescue PlivoXMLError => e
  puts 'Exception: ' + e.message
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
var plivo = require('plivo');

var response = plivo.Response();

var params = {
    'confirmSound': "https://<yourdomain>.com/confirm_sound/",
    'confirmKey': "5"
};
var dial = response.addDial(params);

var first_number = "12025551111";
dial.addNumber(first_number);

var second_number = "12025552222";
dial.addNumber(second_number);

var third_number = "12025553333";
dial.addNumber(third_number);

console.log(response.toXML());

/*
Sample Output
<Response>
    <Dial confirmSound="https://<yourdomain>.com/confirm_sound/" confirmKey="5">
        <Number>12025551111</Number>
        <Number>12025552222</Number>
        <Number>12025553333</Number>
    </Dial>
</Response>
*/


/* Code to generate XML to be returned from url at confirmSound */

var plivo = require('plivo');

var response = plivo.Response();

var speak_body = "Enter the digit 5 to connect the call";
response.addSpeak(speak_body);

console.log(response.toXML());

/*
Sample Output
<Response>
    <Speak>Enter the digit 5 to connect the call</Speak>
</Response>
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
<?php
    require '../vendor/autoload.php';
    use Plivo\XML\Response;

    $response = new Response();

    $params = array(
        'confirmSound'=>"https://<yourdomain>.com/confirm_sound/",
        'confirmKey' => "5"
    );

    $dial = $response->addDial($params);
    $first_number = "12025551111";
    $dial->addNumber($first_number);
    $second_number = "12025552222";
    $dial->addNumber($second_number);
    $third_number = "12025553333";
    $dial->addNumber($third_number);

    Header('Content-type: text/xml');
    echo($response->toXML());

    /*
    Sample Output

    <Response>
        <Dial confirmSound = "https://<yourdomain>.com/confirm_sound/" confirmKey="5">
            <Number>12025551111</Number>
            <Number>12025552222</Number>
            <Number>12025553333</Number>
        </Dial>
    </Response>
    */
?>

<?php
    /* XML to be returned by confirmSound */
    require '../vendor/autoload.php';
    use Plivo\XML\Response;

    $response = new Response();

    $speak_body = "Enter the digit 5 to connect the call";
    $response->addSpeak($speak_body);

    Header('Content-type: text/xml');
    echo($response->toXML());

    /*
    Sample Output

    <Response>
        <Speak>Enter the digit 5 to connect the call</Speak>
    </Response>
    */
?>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// Example for dial - confirm to answer call
package com.plivo.api.xml.samples.dial;

import com.plivo.api.exceptions.PlivoXmlException;
import com.plivo.api.xml.Dial;
import com.plivo.api.xml.Number;
import com.plivo.api.xml.Response;


class ConfirmToAnswerCall {
    public static void main(String[] args) throws PlivoXmlException {
        Response response = new Response()
                .children(


                        new Dial()
                                .confirmKey("5")
                                .confirmSound("https://<yourdomain>.com/confirm_sound/")
                                .children(
                                        new Number("12025551111"),


                                        new Number("12025552222"),


                                        new Number("12025553333")
                                )

                );
        System.out.println(response.toXmlString());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
using System;
using System.Collections.Generic;
using Plivo.XML;

namespace Plivo
{
	class MainClass
	{
		public static void Main(string[] args)
		{
			Plivo.XML.Response resp = new Plivo.XML.Response();
			Plivo.XML.Dial dial = new Plivo.XML.Dial(new
				Dictionary<string, string>() {
				{"confirmSound", "https://<yourdomain>.com/sound/"},
				{"confirmKey", "3"}
			});

			dial.AddNumber("12025551111",
				new Dictionary<string, string>() { });
			dial.AddNumber("12025552222",
				new Dictionary<string, string>() { });
			dial.AddNumber("12025553333",
				new Dictionary<string, string>() { });
			resp.Add(dial);

			var output = resp.ToString();
			Console.WriteLine(output);

		}
	}
}



//<Response>
//  <Dial confirmSound = "https://<yourdomain>.com/sound/" 
//    confirmKey="3">
//    <Number>12025551111</Number>
//    <Number>12025552222</Number>
//    <Number>12025553333</Number>
//  </Dial>
//</Response>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Example for dial - confirm to answer call
package main

import "github.com/plivo/plivo-go/v7/xml"

func main() {
	response := xml.ResponseElement{
		Contents: []interface{}{

			new(xml.DialElement).
				SetConfirmKey("5").
				SetConfirmSound("https://<yourdomain>.com/confirm_sound/").
				SetContents([]interface{}{
					new(xml.NumberElement).
						SetContents("12025551111"),

					new(xml.NumberElement).
						SetContents("12025552222"),

					new(xml.NumberElement).
						SetContents("12025553333"),
				}),
		},
	}
	print(response.String())
}

Example Request

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
from flask import Flask, Response, request
import plivoxml

app=Flask(__name__)

@app.route('/dial/confirm_answer_call/', 
	methods=['GET','POST'])
def confirm_answer_call():
	response = plivoxml.Response()
	params = {
		'confirmSound' : "https://foo.com/confirm_sound/",
		'confirmKey' : "5"
	}
	Dial = response.addDial(**params)
	Dial.addNumber("18217654321")
	Dial.addNumber("15671234567")
	Dial.addNumber("15671289109")
	return Response(str(response), mimetype='text/xml')



if __name__ == "__main__":
	app.run(host='0.0.0.0', debug=True)

# Sample Conference XML
# <Response>
# 	<Dial confirmKey="5" 
#	confirmSound="https://foo.com/confirm_sound/">
#		<Number>18217654321</Number>
#		<Number>15671234567</Number>
#		<Number>15671289109</Number>
#	</Dial>
# </Response>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
require 'rubygems'
require 'plivo'
include Plivo

response = Response.new()

params = {
    'confirmSound' => "https://www.foo.com/confirm_sound/",
    'confirmKey' => "5"
}

dial = response.addDial(params)
first_number = "1111111111"
dial.addNumber(first_number)

second_number = "2222222222"
dial.addNumber(second_number)

third_number = "3333333333"
dial.addNumber(third_number)

puts response.to_xml()

=begin
Sample Output
<Response>
    <Dial confirmKey='5' confirmSound='https://www.foo.com/confirm_sound/'>
        <Number>1111111111</Number>
        <Number>2222222222</Number>
        <Number>3333333333</Number>
    </Dial>
</Response>
=end


=begin
Code to generate XML to be returned from url at confirmSound
=end

response = Response.new()

speak_body = "Enter the digit 5 to connect the call"
response.addSpeak(speak_body)

puts response.to_xml()

=begin
Sample Output
<Response>
    <Speak>Enter the digit 5 to connect the call</Speak>
</Response>
=end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
var plivo = require('plivo');

var response = plivo.Response();

var params = {
    'confirmSound': "https://www.foo.com/confirm_sound/",
    'confirmKey': "5"
};
var dial = response.addDial(params);

var first_number = "1111111111";
dial.addNumber(first_number);

var second_number = "2222222222";
dial.addNumber(second_number);

var third_number = "3333333333";
dial.addNumber(third_number);

console.log(response.toXML());

/*
Sample Output
<Response>
    <Dial confirmSound="https://www.foo.com/confirm_sound/" confirmKey="5">
        <Number>1111111111</Number>
        <Number>2222222222</Number>
        <Number>3333333333</Number>
    </Dial>
</Response>
*/


/* Code to generate XML to be returned from url at confirmSound */

var plivo = require('plivo');

var response = plivo.Response();

var speak_body = "Enter the digit 5 to connect the call";
response.addSpeak(speak_body);

console.log(response.toXML());

/*
Sample Output
<Response>
    <Speak>Enter the digit 5 to connect the call</Speak>
</Response>
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
<?php
    require '../vendor/autoload.php';
    use Plivo\Response;

    $response = new Response();

    $params = array(
        'confirmSound'=>"https://www.foo.com/confirm_sound/",
        'confirmKey' => "5"
    );

    $dial = $response->addDial($params);
    $first_number = "1111111111";
    $dial->addNumber($first_number);
    $second_number = "2222222222";
    $dial->addNumber($second_number);
    $third_number = "3333333333";
    $dial->addNumber($third_number);

    Header('Content-type: text/xml');
    echo($response->toXML());

    /*
    Sample Output

    <Response>
        <Dial confirmSound = "https://www.foo.com/confirm_sound/" confirmKey="5">
            <Number>1111111111</Number>
            <Number>2222222222</Number>
            <Number>3333333333</Number>
        </Dial>
    </Response>
    */
?>

<?php
    /* XML to be returned by confirmSound */
    require '../vendor/autoload.php';
    use Plivo\Response;

    $response = new Response();

    $speak_body = "Enter the digit 5 to connect the call";
    $response->addSpeak($speak_body);

    Header('Content-type: text/xml');
    echo($response->toXML());

    /*
    Sample Output

    <Response>
        <Speak>Enter the digit 5 to connect the call</Speak>
    </Response>
    */
?>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
import java.io.IOException;

import com.plivo.helper.exception.PlivoException;
import com.plivo.helper.xml.elements.Number;
import com.plivo.helper.xml.elements.Dial;
import com.plivo.helper.xml.elements.PlivoResponse;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHolder;

public class confirmToAnswerCall extends HttpServlet {
    private static final long serialVersionUID = 1L;    
    @Override
    protected void doGet(HttpServletRequest req, 
        HttpServletResponse resp)
            throws ServletException, IOException {
        
        PlivoResponse response = new PlivoResponse();
        Dial dial = new Dial();
        dial.setConfirmSound("https://foo.com/confirm_sound/");
        Number number1 = new Number("18217654321");
        Number number2 = new Number("15671234567");
        Number number3 = new Number("15671289109");
        
        try {
            response.append(dial);
            dial.append(number1);
            dial.append(number2);
            dial.append(number3);
            System.out.println(response.toXML());
            resp.addHeader("Content-Type", "text/xml");
            resp.getWriter().print(response.toXML());;
        } catch (PlivoException e) {
            e.printStackTrace();
        }       
    }

    public static void main(String[] args) throws Exception {
        String port = System.getenv("PORT");
        if(port==null)
            port ="8000";
        Server server = new Server(Integer.valueOf(port));
        ServletContextHandler context = new 
        ServletContextHandler(ServletContextHandler.SESSIONS);
        context.setContextPath("/");
        server.setHandler(context);
        context.addServlet(new 
            ServletHolder(new 
                confirmToAnswerCall()), 
                "/dial/confirm_answer_call");
        server.start();
        server.join();
    }
}

/*
Sample Output
<Response>
    <Dial confirmSound="https://foo.com/confirm_sound/">
        <Number>18217654321</Number>
        <Number>15671234567</Number>
        <Number>15671289109</Number>
    </Dial>
</Response>
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
using System;
using System.Collections.Generic;
using Plivo.XML;

namespace Plivo
{
	class MainClass
	{
		public static void Main(string[] args)
		{
			Plivo.XML.Response resp = new Plivo.XML.Response();
			Plivo.XML.Dial dial = new Plivo.XML.Dial(new
				Dictionary<string, string>() {
				{"confirmSound", "https://foo.com/sound/"},
				{"confirmKey", "3"}
			});

			dial.AddNumber("15551234567",
				new Dictionary<string, string>() { });
			dial.AddNumber("18217654321",
				new Dictionary<string, string>() { });
			dial.AddNumber("15671289109",
				new Dictionary<string, string>() { });
			resp.Add(dial);

			var output = resp.ToString();
			Console.WriteLine(output);

		}
	}
}



//<Response>
//  <Dial confirmSound = "https://foo.com/sound/" 
//    confirmKey="3">
//    <Number>15551234567</Number>
//    <Number>18217654321</Number>
//    <Number>15671289109</Number>
//  </Dial>
//</Response>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
    // Example for dial - confirm to answer call
package main

import "github.com/plivo/plivo-go/v7/xml"

func main() {
	response := xml.ResponseElement{
		Contents: []interface{}{

			new(xml.DialElement).
				SetConfirmKey("5").
				SetConfirmSound("https://<yourdomain>.com/confirm_sound/").
				SetContents([]interface{}{
					new(xml.NumberElement).
						SetContents("12025551111"),

					new(xml.NumberElement).
						SetContents("12025552222"),

					new(xml.NumberElement).
						SetContents("12025553333"),
				}),
		},
	}
	print(response.String())
}

Rate this page

🥳 Thank you! It means a lot to us!