Alerts can help people receive crucial updates in a timely manner, allowing them to make timely decisions. You can create SMS alerts easily by using our PHLO visual workflow builder.

Prerequisites

To get started, you need a Plivo account — sign up with your work email address if you don’t have one already. If you’re using a Plivo Trial account, you can send SMS messages only to phone numbers that have been verified with Plivo. You can verify (sandbox) a number by going to the console’s Phone Numbers > Sandbox Numbers page.

Create the PHLO

To create a PHLO, visit the PHLO page of the Plivo console. If this is your first PHLO, the PHLO page will be empty.

• Click Create New PHLO.
• In the Choose your use case pop-up, click Build my own. The PHLO canvas will appear with the Start node.Note: The Start node is the starting point of any PHLO. It lets you trigger a PHLO to start upon one of three actions: incoming SMS message, incoming call, or API request.
• From the list of components on the left-hand side, drag and drop the Send Message component onto the canvas. When a component is placed on the canvas it becomes a node.
• Draw a line to connect the Start node’s API Request trigger state to the Send Message node.

• In the Configuration pane at the right of the canvas, configure the Send Message node with a sender ID in the From field. Enter the destination number you wish to send a message to in the To field. Put your message in the Text field.Note: You can define a static payload by specifying values when you create the PHLO, or define a dynamic payload by passing values through Liquid templating parameters when you trigger the PHLO from your application.
• Once you’ve configured the node, click Validate to save the configuration.

• After you complete the configuration, give the PHLO a name by clicking in the upper left, then click Save.

Your complete PHLO should look like this.

Your PHLO is now ready to test.

Trigger the PHLO

You integrate a PHLO into your application workflow by making an API request to trigger the PHLO with the required payload — the set of parameters you pass to the PHLO. You can define a static payload by specifying values when you create the PHLO, or define a dynamic payload by passing values through parameters when you trigger the PHLO from your application.

In either case, you need your Auth ID and Auth Token, which you can get from the overview page of the Plivo console.

You also need the PHLO ID, which you can copy from the PHLO list page.

With a static payload

When you configure values when creating the PHLO, they act as a static payload.

Code

Create a file and paste the below code.

1
2
3
4
5
6
7
import plivo

phlo_id = "<phlo_id>"
phlo_client = plivo.phlo.RestClient("<auth_id>", "<auth_token>")
phlo = phlo_client.phlo.get(phlo_id)
response = phlo.run()
print(response)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
require 'rubygems'
require 'plivo'

include Plivo

AUTH_ID = '<auth_id>'
AUTH_TOKEN = '<auth_token>'

client = Phlo.new(AUTH_ID, AUTH_TOKEN)

# if credentials are stored in the PLIVO_AUTH_ID and the PLIVO_AUTH_TOKEN environment variables
# then initialize client as:
# client = Phlo.new

begin
  phlo = client.phlo.get('<phlo_id>')
  response = phlo.run()
  puts response
rescue PlivoRESTError => e
  puts 'Exception: ' + e.message
end

1
2
3
4
5
6
7
8
9
10
11
12
var plivo = require('plivo');
var PhloClient = plivo.PhloClient;

var phloId = '<phlo_id>';
var phloClient = phlo = null;

phloClient = new PhloClient('<auth_id>', '<auth_token>');
phloClient.phlo(phloId).run().then(function(result) {
    console.log('Phlo run result', result);
}).catch(function(err) {
    console.error('Phlo run failed', err);
});

1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
require 'vendor/autoload.php';
use Plivo\Resources\PHLO\PhloRestClient;
use Plivo\Exceptions\PlivoRestException;
$client = new PhloRestClient("<auth_id>", "<auth_token>");

$phlo = $client->phlo->get("<phlo_id>");
try {
    $response = $phlo->run();
    print_r($response);
} catch (PlivoRestException $ex) {
    print_r($ex);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import com.plivo.api.Plivo;
import com.plivo.api.PlivoClient;
import com.plivo.api.exceptions.PlivoRestException;
import com.plivo.api.models.phlo.Phlo;
import java.io.IOException;

public class Example
{
    private static final String authId = "<auth_id>";
    private static final String authToken = "<auth_token>";
    private static PlivoClient client = new PlivoClient(authId, authToken);
    public static void main(String[] args) throws IOException, PlivoRestException
    {
        String phloId = "<phlo_id>";
        Plivo.init(authId, authToken);
        Phlo phlo = Phlo.getter(phloId).client(client).get();
        PhloUpdateResponse response = Phlo.updater(phloId).payload().run();
    }
}

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
package main

import (
	"fmt"
	"plivo-go"
)

// Initialize the following params with corresponding values to trigger resources
const authId = "<auth_id>"
const authToken = "<auth_token>"
const phloId = "<phlo_id>"

func main() {
	testPhloRunWithoutParams()
}

func testPhloRunWithoutParams() {
	phloClient, err := plivo.NewPhloClient(authId, authToken, &plivo.ClientOptions{})
	if err != nil {
		fmt.Print("Error", err.Error())
		return
	}
	phloGet, err := phloClient.Phlos.Get(phloId)
	if err != nil {
		fmt.Print("Error", err.Error())
		return
	}
	response, err := phloGet.Run(nil)
	if err != nil {
		fmt.Print("Error", err.Error())
		return
	}
	fmt.Printf("Response: %#v\n", response)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
using System;
using Plivo;

namespace test_PHLO
{
    class Program
    {
        public static void Main(string[] args)
        {
            var phloClient = new PhloApi("<auth_id>", "<auth_token>"); 
            var phloID = "<phlo_id>";
            var phlo = phloClient.Phlo.Get(phloID);   
            Console.WriteLine(phlo.Run());
        }
    }
}

1
2
3
4
curl --request POST \
  --user AUTH_ID:AUTH_TOKEN \
  --url 'https://phlorunner.plivo.com/v1/account/{auth_id}/phlo/{phlo_id}' \
  --header 'Content-Type: application/json'

Replace the auth placeholders with your authentication credentials from the Plivo console. Replace the phlo_id placeholder with your PHLO ID from the Plivo console.

With a dynamic payload

To use dynamic values for the parameters, use Liquid templating parameters when you create the PHLO and pass the values from your code when you trigger it.

Code

Create a file and paste the below code.

1
2
3
4
5
6
7
8
9
10
import plivo

auth_id = '<auth_id>'
auth_token = '<auth_token>'
phlo_id = '<phlo_id>'
payload = {"From" : "<caller_id>","To" : "<destination_number>"}
phlo_client = plivo.phlo.RestClient(auth_id=auth_id, auth_token=auth_token)
phlo = phlo_client.phlo.get(phlo_id)
response = phlo.run(**payload)
print (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
require 'rubygems'
require 'plivo'

include Plivo

AUTH_ID = '<auth_id>'
AUTH_TOKEN = '<auth_token>'

client = Phlo.new(AUTH_ID, AUTH_TOKEN)

# if credentials are stored in the PLIVO_AUTH_ID and the PLIVO_AUTH_TOKEN environment variables
# then initialize client as:
# client = Phlo.new

begin
  phlo = client.phlo.get('<phlo_id>')
  #parameters set in PHLO - params
  params = {
     From: '<caller_id>',
     To: '<destination_number>',
  }
  response = phlo.run(params)
  puts response
rescue PlivoRESTError => e
  puts 'Exception: ' + e.message
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
var plivo = require('plivo');
var PhloClient = plivo.PhloClient;

var authId = '<auth_id>';
var authToken = '<auth_token>';
var phloId = '<phlo_id>';
var phloClient = phlo = null;

var payload = {
    From: '<caller_id>',
    To: '<destination_number>',
}
phloClient = new PhloClient(authId, authToken);
phloClient.phlo(phloId).run(payload).then(function (result) {
    console.log('Phlo run result', result);
}).catch(function (err) {
    console.error('Phlo run failed', err);
});

1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
require 'vendor/autoload.php';
use Plivo\Resources\PHLO\PhloRestClient;
use Plivo\Exceptions\PlivoRestException;
$client = new PhloRestClient("<auth_id>", "<auth_token>");

$phlo = $client->phlo->get("<phlo_id>");
try {
    $response = $phlo->run(["From" => "<caller_id>", "To" => "<destination_number>"]);
    print_r($response);
} catch (PlivoRestException $ex) {
    print_r($ex);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import com.plivo.api.Plivo;
import com.plivo.api.PlivoClient;
import com.plivo.api.exceptions.PlivoRestException;
import com.plivo.api.models.phlo.Phlo;
import java.io.IOException;

public class Example
{
    private static final String authId = "<auth_id>";
    private static final String authToken = "<auth_token>";
    private static PlivoClient client = new PlivoClient(authId, authToken);
    public static void main(String[] args) throws IOException, PlivoRestException
    {
        String phloId = "<phlo_id>";
        Plivo.init(authId, authToken);
        Phlo phlo = Phlo.getter(phloId).client(client).get();
        Map<String, Object> payload = new HashMap<>();
        payload.put("From", "<caller_id>");
        payload.put("To", "<destination_number>");
        PhloUpdateResponse response = Phlo.updater(phloId).payload(payload).run();
    }
}

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
package main

import (
	"fmt"
	"plivo-go"
)

// Initialize these parameters with corresponding values to trigger resources
const authId = "<auth_id>"
const authToken = "<auth_token>"
const phloId = "<phlo_id>"

func main() {
	testPhloRunWithParams()
}

func testPhloRunWithParams() {
	phloClient, err := plivo.NewPhloClient(authId, authToken, &plivo.ClientOptions{})
	if err != nil {
		fmt.Print("Error", err.Error())
		return
	}
	phloGet, err := phloClient.Phlos.Get(phloId)
	if err != nil {
		fmt.Print("Error", err.Error())
		return
	}
	//pass corresponding from and to values
	type params map[string]interface{}
	response, err := phloGet.Run(params{
		"From": "<caller_id>",
		"To":   "<destination_number>",
	})

	if err != nil {
		println(err)
	}
	fmt.Printf("Response: %#v\n", response)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
using System;
using System.Collections.Generic;
using Plivo;

namespace test_PHLO
{
    class Program
    {
        public static void Main(string[] args)
        {
            var phloClient = new PhloApi("<auth_id>", "<auth_token>");
            var phloID = "<phlo_id>";
            var phlo = phloClient.Phlo.Get(phloID); 
            var data = new Dictionary<string, object>
            {
                { "From", "<caller_id>" },
                { "To", "<destination_number>" }

            };  
            Console.WriteLine(phlo.Run(data));
        }
    }
}

1
2
3
4
5
curl --request POST \
  --user AUTH_ID:AUTH_TOKEN \
  --url 'https://phlorunner.plivo.com/v1/account/{auth_id}/phlo/{phlo_id}' \
  --header 'Content-Type: application/json' \
  --data '{"from": "<caller_id>","to": "<destination_number>"}'

Replace the auth placeholders with your authentication credentials from the Plivo console. Replace the phlo_id placeholder with your PHLO ID from the Plivo console. Replace the phone number placeholders with actual phone numbers in E.164 format (for example, +12025551234).

Test

Save the file and run it.

Haven’t tried Plivo yet? Getting started is easy and only takes minutes. Sign up today.

Migrating your Go SMS application from Twilio to Plivo is a seamless and painless process. The two companies’ API structures, implementation mechanisms, XML structure, SMS message processing, and voice call processing are similar. We wrote this technical comparison so that you can scope between Twilio and Plivo APIs for a seamless migration.

Understanding the differences between Twilio and Plivo development

Most of the APIs and features that are available on Twilio are also available on Plivo and the implementation mechanism is easier as the steps involved are almost identical. This table gives a side-side comparison of the two companies’ features and APIs. An added advantage with Plivo is that not only can you code using the old familiar API/XML method, you can also implement your use cases using PHLO (Plivo High Level Objects), a visual workflow builder that lets you create workflows by dragging and dropping components onto a canvas — no coding required.

Plivo offers one unique advantage: Not only can you code using APIs and XML, you can also implement your use cases using PHLO (Plivo High Level Objects), a visual workflow builder that lets you create workflows by dragging and dropping components onto a canvas — no coding required.

Plivo account creation

Start by signing up for a free trial account that you can use to experiment with and learn about our services. The free trial account comes with free credits, and you can add more as you go along. You can also add a phone number to your account to start testing the full range of our voice and SMS features. A page in our support portal walks you through the signup process.

You can also port your numbers from Twilio to Plivo, as we explain in this guide.

Migrating your Go SMS application

You can migrate your existing application from Twilio to Plivo by refactoring the code, or you can try our intuitive visual workflow builder PHLO. To continue working with the APIs, use one of the quickstart guides to set up a development environment for your preferred language. Plivo offers server SDKs in seven languages: Python, Node.js, .NET, Java, Python, Ruby, and Go. For another alternative that lets you evaluate Plivo’s SMS APIs and their request and response structure, use our Postman collections.

How to send an SMS message

Let’s take a look at the process of refactoring the code to migrate your app from Twilio to Plivo to set up a simple Go application to send an SMS message by changing just a few lines of code.

package main

import (
	"encoding/json"
	"fmt"
	"github.com/twilio/twilio-go"
	openapi "github.com/twilio/twilio-go/rest/api/v2010"
	"os"
)

func main() {
    from := 
os.Getenv("TWILIO_FROM_PHONE_NUMBER")
    to := 
os.Getenv("TWILIO_TO_PHONE_NUMBER")
    subaccountSid 
:= os.Getenv("TWILIO_SUBACCOUNT_SID")

    client :=
 twilio.NewRestClientWithParams(twilio.RestClientParams{
        AccountSid: subaccountSid,
    })
    
    params := &openapi.CreateMessageParams{}
    params.SetTo(to)
    params.SetFrom(from)
    params.SetBody("Hello there")
    
    resp, err := client.ApiV2010.CreateMessage(params)
    if err != nil {
        fmt.Println(err.Error())
    } else {
        response, _ := json.Marshal(*resp)
        fmt.Println("Response: " + string(response))
    }
}
   

package main

import (
    "fmt"

    "github.com/plivo/plivo-go/v7"
)

func main() {
    client, err: = plivo.NewClient
    ("<auth_id>",
    "<auth_token>", & plivo.ClientOptions {})
    if err != nil {
        fmt.Print("Error", err.Error())
        return
    }
    response, err: = client.Messages.Create(
        plivo.MessageCreateParams {
            Src: "+14151113333",
            Dst: "+14151112222",
            Text: "Hello, this is a sample text",
            URL: "https://foo.com/sms_status/",
        },
    )
    if err != nil {
        fmt.Print("Error", err.Error())
        return
    }
    fmt.Printf("Response: %#v\n", response)
}

Alternatively, you can implement the same functionality using one of our PHLO templates. For example, if you want to send an SMS message, your PHLO would be this:

How to receive and reply to SMS

You can migrate an application for receiving and replying to an incoming SMS from Twilio to Plivo just as seamlessly, as in this example:

package main

import (
    "net/http"
    "encoding/xml"
)

type TwiML struct {
    XMLName xml.Name `xml:"Response"`

    Message string `xml:",omitempty"`
}

func main() {
    http.HandleFunc("/twiml", twiml)
    http.ListenAndServe(":3000", nil)
}

func twiml(w http.ResponseWriter, r * 
http.Request) {
    twiml: = TwiML {
        Message: "Ahoy! Thanks so much for
        your message.'"
    }
    x,
    err: = xml.Marshal(twiml)
    if err != nil {
        http.Error(w, err.Error(), 
        http.StatusInternalServerError)
        return
    }

    w.Header().Set("Content-Type",
    "application/xml")
    w.Write(x)
}
   

package main

import (
    "net/http"
    "plivo-go/xml"
)

func handler(w http.ResponseWriter, r * 
http.Request) {
    fromnumber: = r.FormValue("From")
    tonumber: = r.FormValue("To")
    text: = r.FormValue("Text")
    print("Message Received - ", fromnumber, " ", tonumber, " ", text)

    response: = xml.ResponseElement {
        Contents: [] interface {} {
            new(xml.MessageElement).
            SetDst(tonumber).
            SetSrc(fromnumber).
            SetContents("Thank you, we received
            your request"),
        },
    }
    w.Write([] byte(response.String()))
}

func main() {
    http.HandleFunc("/reply_sms/", handler)
    http.ListenAndServe(":8080", nil)
}

Here again, you can implement the same functionality using one of our PHLO templates. Your PHLO would look like:

For more information about migrating your SMS applications to Plivo, check out our detailed use case guides, available for all seven programming languages and PHLO.

How to send an MMS message

Let’s take a look at the process of refactoring the code to migrate your app from Twilio to Plivo to set up a simple Go application to send an MMS message by changing just a few lines of code.

package main

import (
    "fmt"
    twilio "github.com/kevinburke/twilio-go"
    "net/url"
)

func main() {
    client: = twilio.NewClient("TWILIO_AUTH_SID", "TWILIO_AUTH_TOKEN", nil)
    gif,
    _: = url.Parse("https://media.giphy.com/media/uGGT9wVlxPAuk/giphy.gif")
    mms,
    _: = client.Messages.SendMessage("FROM_NUMBER", "TO_NUMBER", "", [] * url.URL {
        gif
    })
    fmt.Println("You just sent a gif with Twilio using Go!! " + string(mms.Status) + " - " + string(mms.Sid))
}
   

package main

import (
    "fmt"
    plivo "github.com/plivo/plivo-go/v7"
)

func main() {

        client, err: = plivo.NewClient("<auth_id>", "<auth_token>", & plivo.ClientOptions {})
        if err != nil {
            panic(err)
        }
        createResp, err: = client.Messages.Create(plivo.MessageCreateParams {
            Src: "+14151113333",
            Dst: "+14151112222",
            Text: "Hello, from Go!",
            Type: "mms",
            MediaUrls: [] string {
                "https://media.giphy.com/media/26gscSULUcfKU7dHq/source.gif"
            },
            MediaIds: [] string {
                "801c2056-33ab-499c-80ef-58b574a462a2"
            },
        })
        if err != nil {
            panic(err)
        }

Alternatively, you can implement the same functionality using one of our PHLO templates. For example, if you want to send an MMS message, your PHLO would be this:

More use cases

You can migrate your applications serving other use cases too.

• Two-factor authentication
• Forward incoming SMS
• Delivery reports
• SMS alerts
• SMS marketing
• SMS notifications
• SMS survey
• SMS autoresponder
• Forward SMS to email
• Receive MMS

Simple and reliable

And that’s all there is to migrate your Go SMS app from Twilio to Plivo. Our simple APIs work in tandem with our Premium Communications Network to guarantee the highest possible delivery rates and the shortest possible delivery times for your SMS messages. See for yourself — sign up for a free trial account.

Migrating from Twilio to Plivo is a seamless and painless process. The two companies’ API structures, implementation mechanisms, XML structure, SMS message processing, and voice call processing are similar. We wrote this technical comparison between Twilio and Plivo APIs so that you can scope the code changes for a seamless migration.

Understanding the differences between Twilio and Plivo development

Most of the APIs and features that are available on Twilio are also available on Plivo and the implementation mechanism is easier as the steps involved are almost identical. This table gives a side-side comparison of the two companies’ features and APIs. An added advantage with Plivo is that not only can you code using the old familiar API/XML method, you can also implement your use cases using PHLO (Plivo High Level Objects), a visual workflow builder that lets you create workflows by dragging and dropping components onto a canvas — no coding required.

Plivo account creation

Start by signing up for a free trial account that you can use to experiment with and learn about our services. The free trial account comes with free credits, and you can add more as you go along. You can also add a phone number to your account to start testing the full range of our voice and SMS features. A page in our support portal walks you through the signup process.

You can also port your numbers from Twilio to Plivo, as we explain in this guide.

Migrating your voice application

As mentioned earlier, you can migrate your existing application from Twilio to Plivo by refactoring the code, or you can try our intuitive visual workflow builder PHLO. If you prefer the API approach, you can follow one of the voice quickstart guides based on your preferred language and web framework. Plivo offers server SDKs in seven languages: Python, Node.js, .NET, Java, Python, Ruby, and Go. For another alternative that lets you evaluate Plivo’s SMS APIs and their request and response structure, use our Postman collections.

How to make an outbound call

Let’s take a look at the process of refactoring the code to migrate your app from Twilio to Plivo to set up a simple Go application to make an outbound call by changing just a few lines of code.

package main

import (
    "fmt"
    "github.com/twilio/twilio-go"
    openapi "github.com/twilio/twilio-
    go/rest/api/v2010"
    "os"
)

func main() {
    from: =
    os.Getenv("TWILIO_FROM_PHONE_NUMBER")
    to: =
    os.Getenv("TWILIO_TO_PHONE_NUMBER")

        client: = twilio.NewRestClient()
    
        params: = & openapi.CreateCallParams {}
    params.SetTo(to)
    params.SetFrom(from)
    params.SetUrl("http://twimlets.com/holdmusic?
    Bucket=com.twilio.music.ambient")
    
    resp,
    err: = client.ApiV2010.CreateCall(params)
    if err != nil {
        fmt.Println(err.Error())
    } else {
        fmt.Println("Call Status: " + * resp.Status)
        fmt.Println("Call Sid: " + * resp.Sid)
        fmt.Println("Call Direction: " +
        * resp.Direction)
    }
}
   

package main

import (
    "fmt"
    "github.com/plivo/plivo-go/v7"
)

func main() {
    client, err: = plivo.NewClient("<auth_id>",
    "<auth_token>", & plivo.ClientOptions {})
    if err != nil {
        fmt.Print("Error", err.Error())
        return
    }
    response, err: = client.Calls.Create(
        plivo.CallCreateParams {
            From: "+14151234567",
            To: "+15671234567",
            AnswerURL:
"https://s3.amazonaws.com/static.plivo.com/answer.xml",
            AnswerMethod: "GET",
        },
    )
    if err != nil {
        fmt.Print("Error", err.Error())
        return
    }
    fmt.Printf("Response: %#v\n", response)
}

Alternatively, you can implement the same functionality using one of our PHLO templates. For example, if you want to make an outbound call, your PHLO would be this:

How to receive an incoming call

You can migrate an application for receiving and handling an incoming call from Twilio to Plivo just as seamlessly, as in this example:

package main

import (
  "net/http"
  "encoding/xml"
)

type TwiML struct {
  XMLName xml.Name `xml:"Response"`

  Say    string `xml:",omitempty"`
}

func main() {
  http.HandleFunc("/twiml", twiml)
  http.ListenAndServe(":3000", nil)
}

func twiml(w http.ResponseWriter, r *
http.Request) {
  twiml := TwiML{Say: "Hello World!"}
  x, err := xml.Marshal(twiml)
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    return
  }

  w.Header().Set("Content-Type", "application/xml")
  w.Write(x)
}
   

package main

import (
	"fmt"
	"net/http"
	"github.com/plivo/plivo-go/v7"
)

func handler(w http.ResponseWriter, r *
http.Request) {

	response := xml.ResponseElement{
		Contents: []interface{} {
			new(xml.SpeakElement).
			AddSpeak("Hello, you just
      received your first call"),
		},
	}
	fmt.Printf(response.String())
}

func main() {
	http.HandleFunc("/receive_call/", handler)
	http.ListenAndServe(":8080", nil)
}

Here again, you can implement the same functionality using one of our PHLO templates. Your PHLO would look like:

For more information about migrating your Voice applications to Plivo, check out our detailed use case guides, available for all seven programming languages and PHLO.

How to forward an incoming call

You can migrate an application for forwarding an incoming call from Twilio to Plivo just as seamlessly, as in this example:

package main

import (
    "net/http"
    "encoding/xml"
)

type TwiML struct {
    XMLName xml.Name `xml:"Response"`

    Dial string `xml:",omitempty"`
}

func main() {
    http.HandleFunc("/twiml", twiml)
    http.ListenAndServe(":3000", nil)
}

func twiml(w http.ResponseWriter, r * 
http.Request) {
    twiml: = TwiML {
        Dial: "415-123-4567"
    }
    x,
    err: = xml.Marshal(twiml)
    if err != nil {
        http.Error(w, err.Error(), 
        http.StatusInternalServerError)
        return
    }

    w.Header().Set("Content-Type",
    "application/xml")
    w.Write(x)
}
   

package main

import (
    "net/http"
    "plivo-go/xml"
)

func handler(w http.ResponseWriter, r *
http.Request) {
    response: = xml.ResponseElement {
        Contents: [] interface {} {
            new(xml.DialElement).
            SetContents(
                [] interface {} {
                    new(xml.NumberElement).
                    SetContents
                    ("<destination_number>"),
                },
            ),
        },
    }
    w.Write([] byte(response.String()))
}

func main() {
    http.HandleFunc("/forward_call/", handler)
    http.ListenAndServe(":8080", nil)
}

Here again, you can implement the same functionality using one of our PHLO templates. Your PHLO would look like:

For more information about migrating your Voice applications to Plivo, check out our detailed use case guides, available for all seven programming languages and PHLO.

More use cases

You can migrate your applications serving other use cases too.

• IVR
• Voice-controlled virtual assistant
• Number masking
• Supervisor coaching
• PINless conference
• Conference with PIN
• Voicemail
• Voice alerts broadcasting
• Voice survey
• Dial status reporting
• Screen incoming calls
• Record a call

Simple and reliable

And that’s all there is to migrate your Go voice application from Twilio to Plivo. Our simple APIs work in tandem with our Premium Communications Network. See for yourself — sign up for a free trial account.

This guide shows how to write an autoresponder for SMS text messages. Autoresponders can streamline marketing campaigns and subscription signups and reduce the amount of work humans have to do. You can create a text autoresponder either by using our PHLO visual workflow builder or our SMS API. Follow the instructions in one of the tabs below.

You can create and deploy a PHLO to implement an SMS autoresponder with a few clicks on the PHLO canvas.

How it works

Prerequisite

To get started, you need a Plivo account — sign up with your work email address if you don’t have one already. If you’re using a Plivo Trial account, you can send SMS messages only to phone numbers that have been verified with Plivo. You can verify (sandbox) a number by going to the console’s Phone Numbers > Sandbox Numbers page.

Create the PHLO

To create a PHLO, visit the PHLO page of the Plivo console. If this is your first PHLO, the PHLO page will be empty.

• Click Create New PHLO.
• In the Choose your use case pop-up, click Build my own. The PHLO canvas will appear with the Start node.Note: The Start node is the starting point of any PHLO. It lets you trigger a PHLO to start upon one of three actions: incoming SMS message, incoming call, or API request.
• If you plan to use a dynamic payload — passing values through parameters when you trigger the PHLO from your application — click on the Start node to open the Configuration pane. Under API Request, enter key names for the variables you want to use in your payload — for example, a list of numbers to send an SMS message to.
• Once you’ve configured the node, click Validate to save the configuration.
• From the list of components on the left-hand side, drag and drop the Send Message component onto the canvas. When a component is placed on the canvas it becomes a node.
• Draw a line to connect the Start node’s Incoming Message trigger state to the Send Message node.
• In the Configuration pane at the right of the canvas, configure the Send Message node with a sender ID in the From field. Enter the destination number you wish to send a message to in the To field. Put your message in the Text field.Note: You can define a static payload by specifying values when you create the PHLO, or define a dynamic payload by passing values through Liquid templating parameters when you trigger the PHLO from your application.

• Once you’ve configured the node, click Validate to save the configuration.
• After you complete the configuration, give the PHLO a name by clicking in the upper left, then click Save.

Assign the PHLO to a Plivo number

Once you’ve created and configured your PHLO, assign it to a Plivo number.

• On the Numbers page of the console, under Your Numbers, click the phone number you want to use for the PHLO.
• In the Number Configuration box, select PHLO from the Application Type drop-down.
• From the PHLO Name drop-down, select the PHLO you want to use with the phone number, then click Update Number.

Test

You can now send a message to your Plivo phone number and see how the autoresponder works.

For more information about creating a PHLO application, see the PHLO Getting Started guide. For information on components and their variables, see the PHLO Components Library.

What is MMS Messaging?

When you go out in public these days, few people are interacting with each other — typically, they’re all on their phones. But they aren’t talking — they’re sending GIFs, emojis, and short video clips. This visual content allows consumers to interact with each other and the messaging service that lets you incorporate images, audio, and video into text messages is MMS.

What does MMS mean?

MMS — Multimedia Messaging Service — allows your phone to send emojis, pictures, videos, GIFs, audio recordings, and other non-text content. MMS can be more personalized than a plain text message. While you can send an emoji in an SMS message, you can send a GIF in MMS to amplify the tone of your message.

MMS vs. SMS: Which is better for your use case?

An MMS with graphical elements can be visually engaging for message recipients. Corporate marketing departments have trouble getting potential customers to pay attention to their messages. The visual element that MMS provides can solve that problem. According to Salesmate, “Pop an emoji or emoticon in your subject lines, and your open rates could soar. 56% of brands that use emoticons in that way have higher open rates. It’s something your business can’t afford to neglect.”

MMS has unique strengths for several industries. Consider retail for instance — retailers can use MMS to send coupons with embedded QR codes, or receive product registrations that include images of barcodes or QR codes. We wrote a blog post about how retailers can take full advantage of MMS. Recommended uses include coupons and promotions, personal shopping, product registrations, and branded content. Even if you’re not a retailer, it has ideas you might be able to apply to your business.

You can use MMS for any of the same use cases as SMS. Check out our guide on getting started with SMS marketing for more information.

As MMS is such a personal form of communication, we advise businesses to be thoughtful about when and how they use it. A messaging strategy loses its power when you inundate consumers with irrelevant messages or send messages too often or at inconvenient times, such as when they’re settling into bed for the night.

Plivo’s MMS API

Make sure to work with a high-quality MMS API provider that can provide the features, network, and infrastructure needed to help make your strategy successful. Our guide to choosing an SMS API provider details what you should look for from your SMS/MMS provider. Ultimately you’re looking for an API solution that makes it easy for developers to programmatically send and receive messages, that also leverages the cloud for scalability, and that runs on a global communications network to intelligently and cost-effectively route messages.

The Plivo MMS API lets you send and receive pictures and videos across phone numbers in the US and Canada. Several key features let you easily engage your customers visually.

• You can send and receive MMS messages across the US and Canada via multiple sender types, including long code and toll-free numbers.
• Choose between a variety of multimedia formats, such as image files (JPEG, GIF), emojis, audio (MP3), and video (MP4), for a rich multimedia experience.
• The API intelligently resizes your images to ensure the best delivery across different carrier networks.
• Plivo provides multimedia storage for both inbound and outbound MMS messages for easy access and reuse.
• The API can convert multimedia messages into SMS when you’re sending messages to MMS-incompatible phone numbers.
• Message queuing retries concurrent messaging requests to comply with carrier regulations and offers increased deliverability.

MMS on Powerpack

Plivo’s Powerpack provides a set of features that make message communication at scale more effective and reliable, ensuring that your SMS and MMS messages get delivered at whatever scale you’re sending them, to any country. Powerpack automates all of the complex logic that you would otherwise have to code manually. It’s designed to meet large-scale message throughput and volume requirements. By automatically distributing your overall messaging traffic across a pool of source numbers, Powerpack guarantees that you stay compliant with throughput limits and that your MMS messages get delivered.

Get started with MMS at Plivo

Not sure how to use Plivo for MMS? We’ve written Getting Started guides to sending MMS and receiving MMS for developers who use Node.js, Ruby, Python, PHP, .NET (C#), Java, and Go. And if those aren’t enough, we’ve got answers to several MMS questions in our support portal.

Our competitive pricing starts at $0.0080 for inbound and $0.0160 for outbound MMS messages. Pricing is pay-as-you-go, but discounts may apply to messages sent at higher volumes; you can contact our sales team for higher volume enrollment. Additional carrier surcharge fees may apply to all inbound and outbound MMS usage rates.

Sign up for a free trial of Plivo’s MMS API and automate sending MMS messages to US and Canada phone numbers today.

Migrating from Twilio to Plivo is a seamless and painless process. The two companies’ API structures, implementation mechanisms, XML structure, SMS message processing, and voice call processing are similar. We wrote this technical comparison between Twilio and Plivo APIs so that you can scope the code changes for a seamless migration.

Understanding the differences between Twilio and Plivo development

Most of the APIs and features that are available on Twilio are also available on Plivo and the implementation mechanism is easier as the steps involved are almost identical. This table gives a side-side comparison of the two companies’ features and APIs. An added advantage with Plivo is that not only can you code using the old familiar API/XML method, you can also implement your use cases using PHLO (Plivo High Level Objects), a visual workflow builder that lets you create workflows by dragging and dropping components onto a canvas — no coding required.

Plivo account creation

Start by signing up for a free trial account that you can use to experiment with and learn about our services. The free trial account comes with free credits, and you can add more as you go along. You can also add a phone number to your account to start testing the full range of our voice and SMS features. A page in our support portal walks you through the signup process.

You can also port your numbers from Twilio to Plivo, as we explain in this guide.

Migrating your voice application

As mentioned earlier, you can migrate your existing application from Twilio to Plivo by refactoring the code, or you can try our intuitive visual workflow builder PHLO. If you prefer the API approach, you can follow one of the voice quickstart guides based on your preferred language and web framework. Plivo offers server SDKs in seven languages: Python, Node.js, .NET, Java, Python, Ruby, and Go. For another alternative that lets you evaluate Plivo’s SMS APIs and their request and response structure, use our Postman collections.

How to make an outbound call

Let’s take a look at the process of refactoring the code to migrate your app from Twilio to Plivo to set up a simple Ruby application to make an outbound call by changing just a few lines of code.

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: '+14155551212',
            from: '+14155551212'
)
puts call.sid

   

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(
    '+14151234567',
    ['+15671234567'],
    'https://s3.amazonaws.com/static.plivo.com/answer.xml'
  )
  puts response
rescue PlivoRESTError => e
  puts 'Exception: ' + e.message
end

Alternatively, you can implement the same functionality using one of our PHLO templates. For example, if you want to make an outbound call, your PHLO would be this:

How to receive an incoming call

You can migrate an application for receiving and handling an incoming call from Twilio to Plivo just as seamlessly, as in this example:

require 'sinatra'
require 'twilio-ruby'

post '/twiml' do
  # Start our TwiML response
  Twilio::TwiML::VoiceResponse.new do |r|
    # Use <Say> to give the caller some
    instructions
    r.say(message: 'hello world!', voice: 'alice')
  end.to_s
end

   

include Plivo
include Plivo::XML
include Plivo::Exceptions

class PlivoController < ApplicationController
 def inbound
    response = Response.new
    speak_body = 'Hello, you just received your
    first call'
    response.addSpeak(speak_body)

    xml = Plivo::PlivoXML.new(response)
    render xml: xml.to_xml
 end
end

Here again, you can implement the same functionality using one of our PHLO templates. Your PHLO would look like:

For more information about migrating your Voice applications to Plivo, check out our detailed use case guides, available for all seven programming languages and PHLO.

How to forward an incoming call

You can migrate an application for forwarding an incoming call from Twilio to Plivo just as seamlessly, as in this example:

require 'sinatra'
require 'twilio-ruby'

post '/twiml' do

   response = Twilio::TwiML::VoiceResponse.
   new
   response.dial(number: '415-123-4567')
   response.say(message: 'Goodbye')
   puts response
   end.to_s
end

   

def forward
   response = Response.new
   dial = response.addDial()
   dest_number = "<destination_number>"
   dial.addNumber(dest_number)

   xml = PlivoXML.new(response)
   puts xml.to_xml
   render xml: xml.to_xml
 end

Here again, you can implement the same functionality using one of our PHLO templates. Your PHLO would look like:

For more information about migrating your Voice applications to Plivo, check out our detailed use case guides, available for all seven programming languages and PHLO.

More use cases

You can migrate your applications serving other use cases too.

• IVR
• Voice-controlled virtual assistant
• Number masking
• Supervisor coaching
• PINless conference
• Conference with PIN
• Voicemail
• Voice alerts broadcasting
• Voice survey
• Dial status reporting
• Screen incoming calls
• Record a call

Simple and reliable

And that’s all there is to migrate your Ruby Voice app from Twilio to Plivo. Our simple APIs work in tandem with our Premium Communications Network. See for yourself — sign up for a free trial account.

Migrating your Ruby SMS app from Twilio to Plivo is a seamless and painless process. The two companies’ API structures, implementation mechanisms, XML structure, SMS message processing, and voice call processing are similar. We wrote this technical comparison so that you can scope between Twilio and Plivo APIs for a seamless migration.

Understanding the differences between Twilio and Plivo development

Most of the APIs and features that are available on Twilio are also available on Plivo and the implementation mechanism is easier as the steps involved are almost identical. This table gives a side-side comparison of the two companies’ features and APIs. An added advantage with Plivo is that not only can you code using the old familiar API/XML method, you can also implement your use cases using PHLO (Plivo High Level Objects), a visual workflow builder that lets you create workflows by dragging and dropping components onto a canvas — no coding required.

Plivo offers one unique advantage: Not only can you code using APIs and XML, you can also implement your use cases using PHLO (Plivo High Level Objects), a visual workflow builder that lets you create workflows by dragging and dropping components onto a canvas — no coding required.

Plivo account creation

Start by signing up for a free trial account that you can use to experiment with and learn about our services. The free trial account comes with free credits, and you can add more as you go along. You can also add a phone number to your account to start testing the full range of our voice and SMS features. A page in our support portal walks you through the signup process.

You can also port your numbers from Twilio to Plivo, as we explain in this guide.

Migrating your Ruby SMS application

You can migrate your existing application from Twilio to Plivo by refactoring the code, or you can try our intuitive visual workflow builder PHLO. To continue working with the APIs, use one of the quickstart guides to set up a development environment for your preferred language. Plivo offers server SDKs in seven languages: Python, Node.js, .NET, Java, Python, Ruby, and Go. For another alternative that lets you evaluate Plivo’s SMS APIs and their request and response structure, use our Postman collections.

How to send an SMS message

Let’s take a look at the process of refactoring the code to migrate your app from Twilio to Plivo to set up a simple Ruby application to send an SMS message by changing just a few lines of code.

require 'twilio-ruby'

account_sid = '<account_sid>'
auth_token = '<auth_token>'
client = Twilio::REST::Client.new(account_sid,
auth_token)

from = '+15551234567' # Your Twilio number
to = '+15555555555' # Your mobile phone
number

client.messages.create(
	from: from,
	to: to,
	body: "Hey friend!"
)
   

require 'plivo'
include Plivo

api = 
RestClient.new('<auth_id>','<auth_token>')
response = api.messages.create(
	src:'+14152345678',
	dst:"'+14151112222',
	text:'Hello, from Ruby!'
)
puts response

Alternatively, you can implement the same functionality using one of our PHLO templates. For example, if you want to send an SMS message, your PHLO would be this:

How to receive and reply to SMS

You can migrate an application for receiving and replying to an incoming SMS from Twilio to Plivo just as seamlessly, as in this example:

require 'twilio-ruby'
require 'sinatra'

post '/sms-quickstart' do
  twiml = Twilio::TwiML::MessagingResponse
  .new do |r|
    r.message(body: 'Ahoy! Thanks so much for
    your message.')
  end

  twiml.to_s
end
   

# using Rails
def replysms
	from_number = params[:From]
	to_number = params[:To]
	text = params[:Text]
	response = Response.new
	params = {
		src: to_number,
		dst: from_number,
	}
	message_body = 'Thank you, we
  received your request'
	response.addMessage(message_body
  , params)
	xml = PlivoXML.new(response)
	puts xml.to_xml
	render xml: xml.to_xml
end

Here again, you can implement the same functionality using one of our PHLO templates. Your PHLO would look like:

For more information about migrating your SMS applications to Plivo, check out our detailed use case guides, available for all seven programming languages and PHLO.

How to send an MMS message

Let’s take a look at the process of refactoring the code to migrate your app from Twilio to Plivo to set up a simple Ruby application to send an MMS message by changing just a few lines of code.

require 'rubygems'
require 'twilio-ruby'

account_sid = '<account_sid>'
auth_token = '<auth_token>'
@client = Twilio::REST::Client.new(
account_sid, auth_token)

message = @client.messages
  .create(
     body: 'This is the ship that made the Kessel Run in fourteen parsecs?',
     from: '+15017122661',
     media_url: 
['https://c1.staticflickr.com/3/2899/14341091933_1e92e62d12_b.jpg'],
     to: '+15558675310'
   )

puts message.sid

   

require 'rubygems'
require 'plivo'

include Plivo

api = RestClient.new('<auth_id>','<auth_token>')
  response = api.messages.create(
    src:'+14152345678',
    dst:'+14151112222',
    text:'Hello, from Ruby!',
    media_urls:[
    "https://media.giphy.com/media/26gscSULUcfKU7dHq/source.gif"],
    type: 'mms'
  )
puts response

Alternatively, you can implement the same functionality using one of our PHLO templates. For example, if you want to send an MMS message, your PHLO would be this:

More use cases

You can migrate your applications serving other use cases too.

• Two-factor authentication
• Forward incoming SMS
• Delivery reports
• SMS alerts
• SMS marketing
• SMS notifications
• SMS survey
• SMS autoresponder
• Forward SMS to email
• Receive MMS

Simple and reliable

And that’s all there is to migrate your Ruby SMS app from Twilio to Plivo. Our simple APIs work in tandem with our Premium Communications Network to guarantee the highest possible delivery rates and the shortest possible delivery times for your SMS messages. See for yourself — sign up for a free trial account.

Interactive voice response (IVR) systems let incoming callers access information and find contacts via a menu of pre-recorded messages, without having to speak to an agent, and let you automate polling via outgoing calls. Callers and call recipients can respond to prompts via Touch-Tone keypad presses or speech recognition. IVR systems can handle larger call volumes than operators and reduce costs associated with customer service.

Common IVR use cases include:

• Auto-attendant: You can replace a receptionist with an IVR system that routes calls to agents during business hours and accepts voicemail when no one is available.
• Call center: You can route calls coming in to call centers to the appropriate representatives based on user input.
• Surveys, polling, and voting: You can implement IVR in outbound calls to collect customer satisfaction scores or conduct political polling.
• Appointment reminders: You can send automated reminders to customers before their scheduled visits to help avoid missed appointments and facilitate rescheduling.
• Lead assignment and lead routing: For inbound sales calls, you can set up an IVR menu with a set of qualifying questions to discover a customer’s interests, then redirect their call to a representative based on their responses.

This guide shows how to build an IVR menu system on the Plivo platform, either by using our PHLO visual workflow builder or our APIs and XML documents. This post talks about how to do it with PHLO.

Prerequisites

To get started, you need a Plivo account — sign up with your work email address if you don’t have one already. To receive incoming calls, you must have a voice-enabled Plivo phone number. You can rent numbers from the Numbers page of the Plivo console, or by using the Numbers API.

How it works

You can create and deploy a workflow to implement an IVR system with a few clicks on the PHLO canvas.

Create a PHLO to build a virtual assistant

To create a PHLO, visit the PHLO page of the Plivo console. If this is your first PHLO, the PHLO page will be empty.

• Click CREATE NEW PHLO.
• In the Choose your use case pop-up, click Build my own. The PHLO canvas will appear with the Start node.
  Note: The Start node is the starting point of any PHLO. It lets you trigger a PHLO to start upon one of three actions: incoming SMS message, incoming call, or API request.
• Click the Start node to open the Configuration tab, then enter information that other nodes can retrieve in the API Request section — in this case, the From and optionally To numbers for the IVR system.
• From the list of components on the left side, drag and drop the IVR Menu component onto the canvas. When a component is placed on the canvas it becomes a node.
• Draw a line to connect the Start node‘s Incoming Call trigger state to the IVR Menu node.
• In the Configuration tab at the right of the canvas, configure the choices for the IVR menu. For this example, select 1 and 2 as allowed choices. Enter a message to play to the user in the Speak Text box.
• Once you’ve configured the node, save the configuration by clicking Validate. Do the same for each node as you go along.
• Drag and drop two instances of the Call Forward component onto the canvas. Rename them Connect_to_Support and Connect_to_Sales. Draw lines to connect the IVR Menu node‘s 1 and 2 trigger states to the new nodes.
• Configure each Call Forward node to select the From number using a variable. PHLO will get the number from the key/value pairs set in the Start node. Enter two curly brackets to view all available variables, and choose the appropriate one. For the To number, either enter a fixed number directly into the To field or use a variable that you configured in the Start node.
• Drag and drop two instances of the Play Audio component onto the canvas. Rename the two nodes No_Input_Prompt and Invalid_Input_Prompt and configure each to speak a fixed message for callers to hear when they enter no input or invalid input. Draw lines from the IVR Menu node‘s No Input and Wrong Input trigger states to the respective nodes, then draw lines from the Prompt Completed trigger states of the new nodes back to the IVR Menu node, to give callers another chance to enter a menu choice.
• Give the PHLO a name by clicking in the upper left, then click Save.

Your complete PHLO should look like this.

Refer to the Create the PHLO section in our use case guide for more information.

Assign the PHLO to a Plivo number

Once you‘ve created and configured your PHLO, assign it to a Plivo number.

• On the Numbers page of the console, under Your Numbers, click the phone number you want to use for the PHLO.
• In the Number Configuration box, select PHLO from the Application Type drop-down.
• From the PHLO Name drop-down, select the PHLO you want to use with the phone number, then click Update Number.

Test

You can now call your Plivo phone number and see how the IVR system works.

For more information about creating a PHLO application, see the PHLO Getting Started guide. For information on components and their variables, see the PHLO Components Library.

Plivo’s Premium Communications Network

No other cloud communication platform can match Plivo’s Premium Communications Network (PCN), because it’s taken us 10 years to build it through the careful addition of Tier 1 carrier networks all across the globe. It’s a key competitive advantage that allows Plivo customers to take advantage of a network that delivers high call quality and message deliverability.

A global carrier network

Plivo’s PCN serves a worldwide audience of voice and messaging customers — we have direct relationships with more than 1,600+ carrier networks and connectivity in 190+ countries. Our strict evaluation process approves only carriers that meet the highest industry standards. To ensure top performance for customers in every region, we’ve established seven points of presence (PoP) that correspond to internet exchange points (IXP) in every region around the globe. That means calls outside the local region are routed to their destinations with minimal latency, ensuring maximum voice quality.

Built for reliability

Top performance demands top reliability. We connect with at least two local or Tier 1 direct carriers in each country so we can eliminate multiple hops, lower the overhead of routing, reduce latency, and give our customers the best connections possible. Having multiple carrier connections also gives our customers built-in redundancy to ensure that, in the event of a carrier failure, all voice traffic is automatically routed through alternative carriers to minimize service disruption and quality degradation.

Our PCN delivers a number of practical benefits for our customers, including guaranteed CLI (caller ID) and instant phone number provisioning in every country. Because Plivo manages carrier relationships for our customers, we have a complete end-to-end view of every connection, so we can identify issues and work with carriers to get problems solved, sometimes before our customers even know something went wrong.

Learn more about all the benefits in our free ebook Premium Communications Network: Simplified Cloud-Based Telecom Carrier Infrastructure. You’ll see why no other CPaaS can match our infrastructure.