**** As of October 19, 2022, Plivo has paused Starter registrations.  Please refer to our blog post Updated A2P 10DLC Registration Guidelines in the US for our current 10DLC registration recommendations. ****

Businesses of all sizes can benefit by using text messaging to communicate with their customers and prospects. Texting is inexpensive, it scales easily, and it has global reach, but its main advantage is that people prefer to be contacted by text message. They’d rather receive a text than a phone call or email.

Plivo’s SMS API lets businesses add texting to their applications. You may have heard that there’s a new number type in the US, 10-digit long code (10DLC), that has become the best way to send A2P text messages. Businesses can now register their long codes and get the benefits of better deliverability and potentially higher throughput. However, the registration costs for 10DLC numbers may be a little high for some individuals and small businesses, so we’re introducing a new Starter 10DLC registration plan.

10DLC registration for individuals and small businesses

When you visit the 10DLC registration page of the Plivo console, you’ll now see two options: Standard and Starter. A Standard account lets you register your brand and campaigns and get everything you know and love about Plivo.

Starter is a new option designed for individuals and small businesses that lack a tax identification number or EIN. Its key advantage is its low cost: Starters don’t have to pay a registration fee, just a monthly fee of less than a dollar for a messaging campaign.

The price is right, but Starter brands are more limited than Standard. Starters can register only a single campaign, and associate a maximum of five phone numbers with it. Messaging throughput, which can be as high as 4,500 transactions per minute for a Standard brand, is limited to 75 transactions per minute. But that’s more than enough for a small medical practice that sends out appointment reminders, or any other business that sends out only a few dozen messages a day.

The 10DLC page in our Support portal has more details about Starter brands and all things 10DLC.

SMS services for everyone and anyone

Starter brands and 10DLC phone numbers put text messaging within reach of any organization, from the neighborhood flea market vendor to Fortune 100 businesses.

If you’ve been interested in Plivo but hesitant to make a commitment because you were afraid of receiving a high bill, don’t wait any longer. If you’re a small-businessperson who loved Plivo but had to switch for cost reasons, we’d like to have you back. Sign up for a trial account and use the free credits we provide new customers with to rent a phone number and register your brand, then use Plivo’s SMS API to integrate your applications with our cloud communications platform.

You can create and deploy a workflow to implement conference calling with a few clicks on the PHLO canvas.

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.

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 side, drag and drop the Conference Bridge 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 Conference Bridge node.

• In the Configuration tab at the right of the canvas, enter a Conference ID for your conference. You can also add an announcement message to greet callers, and configure the hold music.
• Once you’ve configured the node, click Validate to save the configuration.

• Give the PHLO a name by clicking in the upper left, then click Save.

Your complete PHLO should look like this.

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 to your Plivo phone number and see how callers are added to a conference call.

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.

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

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.