The Message Element

    The Message element is used to send a message during your call flow. For instance, if you want to send out an SMS notification when you receive an incoming call on your Plivo number, you would use the <Message> XML in your application.

    To receive a message, you must set a message URL in your Plivo application via the API or in the Applications tab from the Dashboard.

    Attributes

    The attributes supported by the Messsage element are listed below. The default behavior of each attribute can be modified using the allowed values.

    src string

    Source Number. For eg.1202322222

    Allowed values - Must be a purchased, valid number.

    dst string

    Destination Number. Can be bulk numbers delimited by <. For eg.1203443444<1203345564

    Allowed values - Must be a valid number.

    type string

    Type of the message. For eg. sms

    Allowed values - sms

    callbackUrl string

    URL that is notified by Plivo when a response is available and to which the response is sent. (Delivery reports)

    Allowed values - a fully qualified URL

    callbackMethod string

    The method used to notify the callbackUrl.

    Allowed values - GET, POST. Defaults to POST.

    Example Request

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    
    from plivo import plivoxml
    
    response = plivoxml.ResponseElement()
    response.add(
        plivoxml.MessageElement(
            'Hi, Message from Plivo',
            src='+12023222222',
            dst='+15671234567',
            type='sms',
            callback_url='http://foo.com/sms_status/',
            callback_method='POST'))
    print(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
    
    require rubygems
    require plivo
    
    include Plivo::XML
    include Plivo::Exceptions
    
    begin
      response = Response.new
    
      params = {
          src: '+12023222222',
          dst: '+15671234567',
          type: 'sms',
          callbackUrl: 'https://www.foo.com/sms_status',
          callbackMethod: 'POST'
      }
      message_body = 'Hi, Message from Plivo'
      response.addMessage(message_body, params)
    
      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
    
    var plivo = require('plivo');
    
    var response = plivo.Response();
    
    var params = {
        'src': "+12023222222",
        'dst': "+15671234567",
        'type': "sms",
        'callbackUrl': "https://www.foo.com/sms_status",
        'callbackMethod': "POST"
    };
    var message_body = "Hi, Message from Plivo";
    response.addMessage(message_body, params);
    
    console.log(response.toXML());
    
    /*
    Sample Output
    <Response>
        <Message src="1111111111" dst="2222222222" type="sms" callbackUrl="https://www.foo.com/sms_status" callbackMethod="POST">
            Hi, Message from Plivo
        </Message>
    </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
    
    <?php
        require '../vendor/autoload.php';
        use Plivo\XML\Response;
    
        $response = new Response();
    
        $params = array(
            'src' => "+12023222222",
            'dst' => "+15671234567",
            'type' => "sms",
            'callbackUrl' => "https://www.foo.com/sms_status/",
            'callbackMethod' => "POST"
        );
        $message_body = "Hi, Message from Plivo";
        $response->addMessage($message_body, $params);
    
        Header('Content-type: text/xml');
        echo($response->toXML());
    
        /*
        Sample Output
    
        <Response>
            <Message src="1111111111" dst="2222222222" type="sms" callbackUrl="https://www.foo.com/sms_status/" callbackMethod="POST">
                Hi, Message from Plivo
            </Message>
        </Response>
        */
    ?>
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    
    // Example for xml - send an sms
    package com.plivo.api.xml.samples.xml;
    
    import com.plivo.api.exceptions.PlivoXmlException;
    import com.plivo.api.xml.Message;
    import com.plivo.api.xml.Response;
    
    
    class SendAnSms {
        public static void main(String[] args) throws PlivoXmlException {
            Response response = new Response()
                    .children(
    
    
                            new Message("+12023222222", "+15671234567", "Hi, message from Plivo.")
                                    .callbackMethod("POST")
                                    .callbackUrl("http://foo.com/sms status/")
                                    .type("sms")
    
                    );
            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
    
    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();
    			resp.AddMessage("Hi, message from Plivo.",
    							new Dictionary<string, string>()
    			{
    				{"src", "+12023222222"},
    				{"dst", "+15671234567" } ,
    				{"type", "sms"},
    				{"callbackUrl", "http://foo.com/sms_status/"},
    				{"callbackMethod", "POST"}
    			});
    
    			var output = resp.ToString();
    			Console.WriteLine(output);
    
    		}
    	}
    }
    
    
    
    //<Response>
    //  <Message src = "12023222222" dst="15671234567" 
    //    type="sms" callbackUrl="http://foo.com/sms_status/" 
    //    callbackMethod="POST">
    //        Hi, message from Plivo.
    //  </Message>
    //</Response>
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    
    // Example for xml - message
    package main
    
    import "github.com/plivo/plivo-go/xml"
    
    func main() {
    	response := xml.ResponseElement{
    		Contents: []interface{}{
    
    			new(xml.MessageElement).
    				SetCallbackMethod("POST").
    				SetCallbackUrl("http://foo.com/sms status/").
    				SetDst("+15671234567").
    				SetSrc("+12023222222").
    				SetType("sms").
    				SetContents("Hi, message from Plivo."),
    		},
    	}
    	print(response.String())
    }