Creating basic conference calls with Plivo is easy. But what if you want more control for advanced contact center and sales dialer use cases, such as:

• being able to dial out to another agent or supervisor directly from the call
• being able to do a warm transfer to another agent
• enabling a supervisor to coach an agent without the customer listening to it
• playing custom background audio to different parties

At Plivo, we understand how important it is for call centers and sales teams to monitor the performance of their agents using recorded calls as reference for training. Gathering insights driven by AI technologies helps improve the overall quality of their service.

That’s why we’re excited to announce our multiparty calls component in public beta, which gives customers the ability to assign roles like agent, customer, and supervisor to participants of a call. Using this, businesses can manage the user experience programmatically by adding and removing agents on the call, performing warm and cold transfers, and enabling supervisor coaching. Multiparty calls can be used for standard multiparty audio bridges, inbound contact centers, and outbound sales dialers, for up to 10 participants.

For traditional “meeting” use cases where more participants may need to be connected, please checkout our conference offering.

Here are some great features that can help you enhance your experience with our multiparty call component.

Assign agent and customer roles

Businesses can assign users roles and trigger different permissions accordingly. You can configure a multiparty call so that the agent can initiate and manage transfers, and can even specify different hold music to be played to the agent and the customer. You can also assign a ”supervisor” role to appropriate stakeholders so they have the ability to monitor calls as they see fit.

Coaching functionality

Businesses can also take advantage of coaching functionality. A coach participant can talk to one participant without the other caller hearing the audio. This is a must-have in call centers that want agents to perform well and provide excellent service. Coaching provides a way for call center agents to learn new skills, get feedback on the work they’re doing in real time, and get to the heart of problems they’re experiencing.

Call recording controls

Businesses will have the flexibility to determine which parts of the conversations are recorded. This means adding commands to record the leg of any conference call. This is especially useful when an agent wants to start a call recording only after the customer provides consent to record, or pause an active recording when collecting payment information. Many agents need to collect PII (personally identifiable information), but it could be a liability to have that information stored in a recording if it isn’t necessary. Many prefer to pause the recording while collecting the PII, then resuming the recording immediately afterward.

You can even go as far as setting controls at the participant level, so that if a supervisor is on the call to coach an agent in real time, you can configure the recording to only be inclusive of the customer’s audio.

Warm transfers

Finally, businesses can add people to an in-progress phone call to provide a seamless customer experience — also known as a warm transfer. Some businesses have a receptionist speak with the appropriate agent before they send a call to them, or a representative from one department briefs another colleague about the inquiry at hand before transferring the customer. Typically, a caller is put on hold while the call center operator dials the desired extension. After being notified, the transfer destination can then accept the call and complete the transfer. Taking a moment to make sure the transfer recipient has all pertinent info goes a long way in customer service toward ensuring clients’ continued happiness.

Multiparty calling programmatically adds the right participants at the right time to streamline customer support and virtual coaching sessions and consultations, while also assigning proper user permissions using only participants’ phone numbers. And getting started is easy — just check out our thorough API Reference Guide to learn more.

Plivo’s multiparty calling component is available in public beta. Haven’t tried Plivo yet? Getting started only takes five minutes! Sign up today.

The COVID-19 pandemic has changed people’s behavior in a lot of ways — among them, how they interact with businesses. Businesses that want to maintain communication with customers and prospects need to consider how their communication strategies have to change in light of a more online, remote, and virtual world.

At Plivo, we spend a lot of time thinking about how to help businesses communicate better. We just published an ebook called Rethinking Business Communications: Plivo’s Guide to Better Customer Experience in 2021. You should download it to get our perspective on how you can adapt your communications to meet changing customer expectations. Here’s a taste of what you’ll find in the ebook.

Reach out strategically

Want to stay in touch with your customers? SMS and MMS is the way to go. SMS messages have a 98% open rate, 90% of text messages are read within three minutes, and text messages have a 209% higher response rate than phone, email, or Facebook.

Businesses can use text messaging to their advantage, but the details can trip them up. Should they use long code phone numbers or short codes? What about the new 10DLC numbers? How do you send potentially hundreds of thousands of messages and meet throughput requirements while staying in compliance with carriers’ restrictions on messaging volumes? The ebook offers some tips, and if they’re not enough, we’ve written a blog post on SMS best practices.

Let customers help themselves

Customers don’t always need you to help them get where they want to go. And we’re not talking about just pushy salespeople in retail shops — every business is moving toward more self-service.

One way to automate self-service is through interactive voice response (IVR) systems. With a good IVR setup, customers can open service tickets, pay bills, schedule payments, book appointments, and track order shipments. On our website, we’ve got a great tutorial on how to put together an IVR system using PHLO, our visual workflow builder, or by using our APIs in any of seven popular programming languages.

Always be there

Customers and potential customers expect businesses to be there for them all the time. That can be tough on a company’s social media team — but hey, we’re all having trouble sleeping these days, so maybe responding to tweets at 3 a.m. isn’t so bad.

When it comes to business communications, always being there means having a communications infrastructure that’s always online. That’s especially important for tasks like two-factor authentication, for example. It’s critical that every 2FA voice and SMS message gets delivered within the 10- to 15-second window that avoids disruption in the customer experience.

Plivo provides 99.99% uptime, as do other cloud communications platforms, but even that may not be enough. That’s why it pays to have a fallback channel — a second provider that can step in and seamlessly maintain your availability. Having a second communications platform can also help you load-balance your messaging when both platforms are up.

Communications for a changed world

Those are just a few of the tips and hints you’ll see in our latest ebook. We think you’ll find additional observations in it that can help your business.

It’s going to be a long time before we give up social distancing for group hugs, and elbow bumps for handshakes. We might never get back to our old habits of doing business primarily in person. Download our Rethinking Business Communications ebook for more tips on how to meet today’s customers’ changing communication expectations.

Put yourself in the shoes of the average, everyday consumer, and imagine you get two text messages from two different companies. The first message comes from a seemingly random number that you don’t recognize, and the other has a clear sender.

Which one will you ignore or delete? Which one will you open and read? Which one are you more likely to trust?

Sender identification codes (sender IDs for short), help message recipients more easily identify who a message is coming from. When recipients see an ID they recognize, they’re more likely to trust the message they’re receiving and open it.

In short, sender IDs can help you get better results from your SMS campaigns.

Not every country supports sender IDs (more on that below), but in the countries that do, they’re an effective way for businesses to successfully engage with their customers.

In this article, we’ll cover what sender IDs are, why and where businesses should use them, and how they can enhance SMS campaigns.

What are sender IDs?

Sender IDs are alphanumeric identifiers you can use to brand your text messages and show your customers who you are before they tap the message to read it.

Sender IDs can use any combination of numbers and letters up to 11 characters (except in India, which requires exactly six characters) to spell out a brand name, a product, or almost anything you want.

It’s important to note that alphanumeric sender IDs are not available everywhere. In fact, carriers in nearly all of the Western Hemisphere, including the US and Canada, plus China, don’t support alphanumeric sender IDs.

If your SMS campaigns are limited to those areas, you can skip the rest of this article, though we encourage you to learn about Google Verified SMS as an alternative.

If  you send messages to customers in Europe, Asia, and Australia, sender IDs can be an important tool for your campaigns.

Why use sender IDs?

Sender IDs can be a critical part of successful SMS campaigns because they help you create trust among your customers, and may lead to greater engagement with your messages.

When you get a message from someone you know, you’re more likely to open and read that message. Customers who have opted in to receiving your messages should recognize your sender ID and associate it with your brand. That’s important in establishing trust and helping to make sure they open future messages.

On the other hand, without a sender ID, you could be diminishing your brand. Customers may not connect your message to your brand, and will almost certainly forget the random number your message comes from. This could make them less likely to open and read your messages in the future.

The upshot is that using sender IDs is an SMS best practice for building brand familiarity with your customers. In some cases, it’s a necessity. Many countries require sender IDs.

Does that mean that if you need to reach customers in the US and Canada, where alphanumeric sender IDs aren’t available, you shouldn’t consider SMS campaigns? Certainly not. No matter where you’re sending text messages, SMS is an effective way to reach customers — but if sender IDs are an option, you should use them.

When should you use sender IDs?

It’s almost always a good idea to use branded sender IDs when running an SMS campaign in which some of the recipients are in countries that support them. Here are some specific use cases where it’s especially important.

Reminders/alerts/notifications

SMS notifications allow businesses to disseminate critical information with reach, immediacy and ease. This is especially important for time-sensitive notifications such as flight changes or appointment reminders. A sender ID helps ensure that recipients recognize the sender as a trusted contact.

Banking/financial

If you’re sending messages for two-factor authentication to allow users to set up accounts, reset passwords, or conduct other private business, you can help customers feel confident they’re being contacted by the right company so they can avoid falling for scams or compromising their private data.

Marketing/promotions

When you’re contacting customers to advise them of an offer, promote a product, or simply to build your brand, sender IDs are critical. Without them, customers may assume your message is a scam, or simply ignore it, even if they opted into your messages.

Ride-hailing/delivery

As with the other examples, SMS campaigns advising of a ride-hailing arrival or order delivery require trust. People want to make sure the entity contacting them, asking them to open their doors, is legitimate.

Customer nurturing

One of the most powerful ways to use SMS is to engage customers after they’ve taken an action or attended an event. A well-placed message can drive customers toward a purchase. Seeing a branded sender ID allows them to instantly make the connection to their previous experience with the brand, and they may be more likely to engage.

Plivo makes sender IDs easy with registration in the console

Rules and practices around sender IDs vary by country, beginning with the registration of the IDs. Some countries require that IDs be preregistered, while others don’t. In countries that do require preregistration, companies need to provide information, and sometimes additional documents, to validate the sender IDs they wish to use. Depending on the country, sender ID validation can take up to two weeks to complete.

Sender IDs need to be registered and maintained separately for each country, which can be a cumbersome process when you want to send messages to multiple countries. However, Plivo’s SMS API simplifies the process by managing all of your registrations from the Plivo console, reusing documents, and tracking progress as you go. You don’t have to manually send documents to each country, and you can track the status of your registration in real time.

To learn more about sender ID registration, read our guide to sender ID registration or talk to one of our experts.

Your company has settled on Plivo to handle its voice and messaging communications, and now it’s your job to start integrating Plivo into your company’s applications. Don’t worry — Plivo has an SDK to help you out. Let’s see how to make outbound calls and handle incoming calls through Plivo in a Go application.

Install the Plivo SDK

We’ll presume you already have your Go environment set up. Change to the directory into which you want to install the Plivo Go SDK and run

$ go get github.com/plivo/plivo-go/v7

or you can clone our GitHub repository into your GOPATH.

Find your Auth ID and Auth Token

You have to have proper credentials before you can use the Plivo API. We provide an Auth ID and Auth Token in the Account section at the top of the overview page of the Plivo console.

Choose a phone number

You need an voice-enabled Plivo phone number if you want to receive incoming calls. Check the Numbers screen of the Plivo console to see what numbers you have available. You can also rent numbers from this screen.

Use PHLO to set up an outbound call

Now you can turn to PHLO, Plivo’s visual workflow design studio, to set up the workflow for an outbound call. Click on the PHLO icon on the left-side navigation bar, then on Create New PHLO. In the window that pops up, click Build My Own.

Let’s start with a very simple workflow. From the list of components on the left side, drag and drop the Initiate Call component onto the canvas, then connect the Start node to the Initiate Call node using the API Request trigger state.

Now you can add configuration information for the call in the right pane. Valid phone numbers begin with a plus sign and a country code. Add a caller ID number in the From field and a destination number in the To field, then click Validate to save the configuration.

PHLO lets you use variables for From and To values, but we’re keeping it simple for this example.

Now drag the Play Audio component onto the canvas. Connect the Initiate Call node to Play Audio using the Answered trigger state. In the Configuration panel, enter the text you want to play for the call recipient, then click Validate.

That’s all we’re going to do for now — we told you it was simple. Give the PHLO a name by clicking on the pencil icon in the upper left, then click the Save button in the upper right.

Run the PHLO to make a call

Now you can trigger the PHLO and test it out. Copy the PHLO ID from the end of the URL of the workflow you just created. You’re also going to need your Auth ID and Auth Token. Create a Go source code file — let’s call it TriggerPhlo.go — and paste this code into it:

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
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)
}

Substitute actual values for <auth_id>, <auth_token>, and <PHLO_ID>. Save the file and run it with the commandBoom — you’ve made an outbound call.

$ go run TriggerPhlo.go

Set up inbound calls

Of course outbound calls are only half of the equation. Plivo supports inbound calls as well. To see how, let’s create another PHLO and again specify Build My Own. This time, drag the Play Audio component onto the canvas and connect the Start node to it using the Incoming Call trigger state. In the Configuration panel, enter some text to speak to the caller when the call is answered, then click Validate to save the configuration. Give this PHLO a name, then click Save.

Before you can receive a call using this PHLO, you have to assign it to a Plivo number. Go back to the Plivo console and click on Phone Numbers on the left nav bar. From the list of Your Numbers, click on the number you want to use. On the next screen, from the Application Type dropdown, choose PHLO. From the PHLO Name dropdown, choose the PHLO you just created. Then click Update Number at the bottom of the screen.

Guess what? You’re done! You don’t have to run a program for this PHLO to work. Just call the Plivo number you specified and you should hear the message you configured read by Plivo’s text-to-speech processor.

Conclusion

And that’s all there is to sending and receiving voice calls using Plivo’s Go SDK. Don’t use Ruby? Don’t worry — we have SDKs for PHP, Java, Node.js, Python, .NET Core, .NET Framework, and Ruby.

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

Remember playing “telephone” when you were a kid? One of your friends would think of a message, then whisper it into the next kid’s ear, who would then pass it on to the next in line.

Turns out, playing telephone is a lot like using SMS to send messages internationally — except that one of the kids in the chain may suddenly decide to use a different language, or wait several hours before relaying the message, or not pass the message on at all.

Delivering SMS messages across multiple countries is a tricky game that requires you to rely on unreliable networks. Too often, that means your messages don’t get through.

If sending SMS messages is important to your business, it’s important to know why the process can be challenging. Chances are you use, or are considering, an SMS API platform as the infrastructure to integrate SMS with your applications. By learning about potential bottlenecks, you can evaluate an SMS API provider on how they can help you overcome the difficulties and maximize your success.

Problem: potential network issues

Sending an SMS message seems like it should be simple and straightforward. You press Send and your message goes out and pops up on the recipient’s handset.

If you’re sending SMS messages within the United States and Canada, you can usually count on that process happening with no surprises. But sending messages to users in other countries can be complex. Your message may have to pass across unreliable networks, due to the inherent complexities of sending SMS messages globally.

When you send messages internationally through an SMS API provider, the messages navigate a labyrinth of networks, hubs, and carriers. Every time your messages get handed off from one carrier to another, the potential for problems multiplies.

Think of it like air travel: If you have a direct flight or just one connection, chances are you’ll reach your destination on time. But if you have multiple connections through different countries on different airlines, your chance of encountering delays increases.

Likewise, international mobile networks and carriers can introduce complexities that cause your SMS messages to fail in a variety of ways.

Messages may be delayed

When sending SMS messages, you expect your messages to be delivered instantly. However, if you’re dealing with multiple carriers and aggregators (businesses that decide how to route messages to different carriers) around the globe, that’s not guaranteed.

Depending on your use case, delays of up to a minute or two might be OK, as long as the message gets delivered. But for time-critical messages, such as one-time passwords or two-factor authentication messages, a delay of just 20 seconds is the same as failure.

The message might look different than expected

Some networks struggle with delivering a message in the format in which it was created. Longer messages might be split up into multiple messages, or the networks might not support special characters, such as Unicode or GSM.

Format changes could alter a message’s intent, leave the user confused, or even render the message unreadable. And unexpected changes may cause recipients to dismiss a message entirely.

The sender ID might not be retained

With many networks, it’s not guaranteed that yoursender ID will be retained. If users don’t recognize the sender, they may dismiss the message or, worse, block the sender.

The message may never be delivered

Another frustrating thing that can happen when you send SMS messages to users is that the message simply doesn’t show up, and you may never know it.

Unfortunately, this scenario does happen with some networks. Messages don’t get sent, and delivery reports don’t reflect what actually happened.

Low-quality mobile carriers in many countries don’t provide delivery reports on SMS messaging, making it impossible for companies to evaluate their campaigns. Some carriers that do provide reports may even lie about them.

With the problems and unreliability of sending global SMS messages, the situation may seem hopeless. But with the right SMS API provider, you can overcome these challenges.

Plivo helps you get messages through — no matter what

Plivo’s SMS API platform helps you run a successful SMS program, even on unreliable networks. We make sure that your messages not only get delivered but also maintain their integrity and accuracy.

We achieve that by not working with aggregators, but instead maintaining our own relationships with high-quality carriers. That ensures that our customers’ messages don’t get stuck in an aggregator’s infrastructure, but instead take a more direct route to users’ handsets.

One of the techniques we use in countries with multiple carriers is to use handsets as global test nodes. Using this technique, the platform sends messages to the test nodes and measures the results, including deliverability, speed, sender ID confirmation, and character set. Based on this feedback, we can choose the best route to maximize delivery success.

Another approach we use for one-time password messages is to mark them as trackable. When a user receives such a message and successfully authenticates, the platform gets those results reported back. Our delivery reports then let customers measure performance. It’s important to know that you can evaluate carriers on their consistently high deliverability rates.

Our platform supports different character sets in different countries and languages, and with different carriers. GSM is the standard default encoding, and our intelligent message system will automatically encode any text message that contains a Unicode character into the equivalent GSM character. We also ensure that your messages are not split up, so they’re delivered the way you intend.

Another way we help ensure accurate delivery is by supporting sender IDs, which are required in many countries to make delivery easy. A sender ID is what appears on someone’s phone to indicate who sent the message. If your sender ID isn’t retained through the delivery process, it can slow down delivery and reduce trust among your users. Plivo’s SMS API platform makes sender ID registration easy, so your users trust your messages.

Regulatory compliance

User data and privacy regulations vary from country to country, making compliance complicated, but it’s critical that you follow regulatory guidelines. Running afoul of data privacy and opt-out rules can put your whole program in jeopardy and potentially subject you to penalties.

Our SMS API platform helps you make sure you’re meeting all of the necessary requirements by

• protecting and purging sensitive customer data,
• complying with each country’s frequency limits, and
• offering simple, automatic opt-outs.

With these features, we can help ensure that your SMS messages comply with relevant regulations.

Reliability strategy

As we’ve mentioned, carriers in some countries are unreliable. We partner with Tier 1 carriers that promise high deliverability and accurate reporting. But even those carriers occasionally have problems, so we’ve built a redundant carrier network. If one carrier’s systems are down, we can automatically reroute messages to the next best available carrier. As a result, we guarantee uptime and availability rates that work out to less than an hour of downtime over the course of a year.

Geographic coverage

As your business grows, you may need to contact customers regardless of where they are in the world.

Our platform features a quality-based routing engine that provides fast global delivery. Our real-time message delivery and opening feedback reporting help us evaluate carrier routing with you, so we can apply those insights to future campaigns.

Plivo can even help with open and response rates. Depending on your use case, we can automatically select local phone numbers based on recipients’ area codes. Recipients are more likely to trust and open a message when they see that it comes from a local number.

Custom solutions

Businesses have varying needs and use cases for SMS campaigns. Whether you’re sending promotional texts or time-sensitive messages for two-factor authentication, Plivo lets you quickly and easily customize, scale, and integrate features that matter to you.

We let you deliver messages using consistent sender IDs to maintain trust and connection with your customers. You can customize your code quickly and easily to simplify your campaign deployments, and segment your customers to track campaign performance.

And that’s just the beginning. Plivo offers the solutions you need to run successful campaigns.

Choose an SMS API that reliably delivers your messages

To reach customers by text message, you need an SMS API provider that ensures your messages get through. Our SMS API platform and global delivery network help leading businesses reach their global customer base in minutes with SMS autoresponders, surveys, marketing, reminders, and more.

To learn more about the Plivo SMS API platform,talk to one of our experts.

Your company has settled on Plivo to handle its voice and messaging communications, and now it’s your job to start integrating Plivo into your company’s applications. Don’t worry — Plivo has a Go SDK to help you out. You can use it write Go applications that send and receive SMS messages.

Prerequisites

To get started, you need a Plivo account — sign up with your work email address if you don’t have one already. If this is your first time using Plivo APIs, follow our instructions to set up a Go development environment.

Send an SMS message

Now you’re ready to start. Create a file called SendSMS.go and paste into it this code.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

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

func main()  {
  client, err := plivo.NewClient("<auth_id>","<auth_token>", &plivo.ClientOptions{})
  if err != nil {
    panic(err)
  }
  client.Messages.Create(plivo.MessageCreateParams{
    Src: "<sender_id>",
    Dst: "<destination_number>",
    Text: "Hello, world!",
  })
}

Replace the auth placeholders with actual values from the Plivo console. Replace the phone number placeholders with actual phone numbers in E.164 format (for example, +12025551234). In countries other than the US and Canada you can use a sender ID for the message source. You must have a Plivo phone number to send messages to the US or Canada; you can rent a Plivo number from Phone Numbers >Buy Numbers on the Plivo console or via the Numbers API. Save the file and run it.

$ go run SendSMS.go

Note: If you’re using a Plivo Trial account, you can send 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.

Receive an SMS message

Of course sending messages is only half of the equation. Plivo supports receiving SMS text messages in many countries (see our SMS API coverage page and click on the countries you’re interested in). When someone sends an SMS message to a Plivo phone number, you can receive it on your server by setting a Message URL in your Plivo application. Plivo will send the message along with other parameters to your Message URL.

Create a file called receive_sms.go (or whatever name you like) and paste into it this code.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import (
	"net/http"
)

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)
}

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

Save the file and run it.

$ go run receive_sms.go

You should then be able to see your basic server app in action on http://localhost:8080/receive_sms/.

That’s fine for testing, but it’s not much good if you can’t connect to the internet to receive incoming messages and handle callbacks. For that, we recommend using ngrok, which exposes local servers behind NATs and firewalls to the public internet over secure tunnels. Install it and run ngrok on the command line, specifying the port that hosts the application on which you want to receive messages.

$ ./ngrok http [portnum]

Ngrok will display a forwarding link that you can use as a webhook to access your local server using the public network.

Now you can create an application to receive SMS messages (follow our Quickstart guide for details).

Conclusion

And that’s all there is to sending and receiving SMS messages using Plivo’s Go SDK. Don’t use Go? Don’t worry — we have SDKs for Java, Python, PHP, Node.js, Ruby, .NET Core, and .NET Framework.

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

Once you’ve chosen Plivo to handle your company’s voice and messaging channels, it’s time to start integrating Plivo’s tools into your company’s applications. We make this process easy with a .NET SDK to help you out. Use it to write .NET applications that send and receive SMS messages.

In this guide, we’ll explain how to send and receive SMS messages using .NET. We'll walk you through how to up your account, write code snippets for sending messages, and receive responses through our SMS API. By the end, you'll be ready to leverage SMS communication for notifications, alerts, or even two-way interactions in .NET.

Prerequisites

Before you dive into the steps to set up Plivo’s SMS API with ASP.NET Core, make sure the following prerequisites are in place. 

• A Plivo account— sign up with your work email address if you don’t have one already. 
• Install .NET Framework 4.6 or higher
• Install the Plivo .NET SDK using Visual Studio
• Trigger an API request
• Set up a .NET Framework application
• Set up ngrok

The prerequisites listed above are part of the instructions to set up a .NET development environment. If this is your first time using Plivo APIs, follow our guide to set up your dev environment to send and receive SMS messages.

{{cta-style-1}}

Send an SMS message with ASP.NET Core

Now you’re ready to start. Open the file Program.cs in the CS project and paste into it this code.

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

namespace testplivo
{
    internal class Program
    {
        public static void Main(string[] args)
        {
            var api = new PlivoApi("<auth_id>","<auth_token>");
            var response = api.Message.Create(
                src: "<sender_id>",
                dst: "<destination_number>",
                text: "Hello, world!"
                );
            Console.WriteLine(response);
        }
    }
}

Replace the auth placeholders with actual values from the Plivo console. Replace the phone number placeholders with actual phone numbers in E.164 format (for example, +12025551234). In countries other than the US and Canada you can use a sender ID for the message source. You must have a Plivo phone number to send messages to the US or Canada; you can rent a Plivo number from Phone Numbers >Buy Numbers on the Plivo console or via the Numbers API. Save the file and run it.

$ dotnet run

Note: If you’re using a Plivo Trial account, you can send 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.

Receive an SMS message with ASP.NET Core MVC

Of course sending messages is only half of the equation. Plivo supports receiving SMS text messages in many countries (see our SMS API coverage page and click on the countries you’re interested in). When someone sends an SMS message to a Plivo phone number, you can receive it on your server by setting a Message URL in your Plivo application. Plivo will send the message along with other parameters to your Message URL.

Begin by setting up a .NET Core app. Create a new project directory.

$ mkdir receivesmsapp

Change to that directory and initialize the model-view-controller (MVC) architecture with the command

$ dotnet new mvc --no-https

Change to the Controllers directory. Create a controller named ReceiveSmsController.cs and paste into it this code.

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 Microsoft.AspNetCore.Mvc;

namespace ReceiceSms.Controllers
{
    public class ReceiveSmsController : Controller
    {
        // GET: /<controller>/
        public String Index()
        {
            // Sender's phone number
            String from_number = Request.Form["From"];
            // Receiver's phone number
            String to_number = Request.Form["To"];
            // The text that was received
            String text = Request.Form["Text"];
            // Print the message
            Console.WriteLine("Message received - From: {0}, To: {1}, Text: {2}", from_number, to_number, text);

            return "Message received";
        }
    }
}

Before you can test the application, edit Properties/launchSettings.json and set the applicationUrl.

"applicationUrl": "http://localhost:5000/"

Then start the local server with the command

$ dotnet run

You should then be able to see your basic server app in action on http://localhost:5000/receivesms/.

That’s fine for testing, but it’s not much good if you can’t connect to the internet to receive incoming messages and handle callbacks. For that, we recommend using ngrok, which exposes local servers behind NATs and firewalls to the public internet over secure tunnels. Install it and run ngrok on the command line, specifying the port that hosts the application on which you want to receive messages.

$ ./ngrok http [portnum]

Ngrok will display a forwarding link that you can use as a webhook to access your local server using the public network.

Now you can create an application to receive SMS messages (follow our Quickstart guide for details).

Why integrate Plivo’s SMS API with ASP.NET?

ASP.NET provides a strong foundation for integrating Plivo’s SMS API with your business tech stack. Many developers are already well-versed in C# and Visual Studio, making it faster and easier to leverage this framework for your web application. 

Keeping your SMS logic within your ASP.NET application simplifies code management and maintenance. Everything is in one place. And, it scales well for handling high volumes of SMS traffic. Beyond SMS, ASP.NET allows you to integrate with other functionalities like email, databases, and user authentication, creating a powerful web application ecosystem.

Conclusion

That’s all there is to sending and receiving SMS messages using Plivo’s .NET Core SDK. Don’t use .NET Core? Don’t worry — we have SDKs for Java, Python, PHP, Node.js, Ruby, and Go.

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

The most frequent question we hear from our SMS API customers is “How can I scale my application to send more messages?” and our answer is always the same and very simple — Powerpack.

What is Powerpack? You can think of it as a global routing and delivery system that spreads high-volume messaging traffic over several phone numbers for high delivery rates at the lowest possible cost.

Sending messages at scale and deciding which numbers to use can be a thankless and time-consuming task. To stay compliant, you have to be aware of things like carrier filtering, rate limits, and country-specific regulations.

Plivo has built-in logic that takes all of those things into consideration and automates the work for you, so you don’t need to devote any developer resources to the task. All you have to do is build a number pool for Powerpack, from which Plivo will distribute your outbound messages, and you can opt in to any of Powerpack’s automation features, including:

• Sticky Sender, which maintains the mapping of the “to and from” phone numbers so you send messages to the same customer from the same phone number every time, and ensure a single conversation thread.
• Local Connect, which allows you to match the country or area code with your customer’s phone number.
• Smart Encoding, which detects Unicode characters and replaces them with equivalent GSM-encoded characters when possible, saving you money.
• Automatic Fallback, which gives you the flexibility to set priority parameters by phone number type and assign some as fallback numbers, in case messages fail to be delivered. For example, if a customer is concerned with cost optimization, they can set toll-free numbers as their priority numbers, and assign long codes as automatic fallback numbers, to be used only in case of network outages or end user restrictions. If a customer is more concerned with deliverability, they can prioritize short codes and assign toll-free numbers or long codes as automatic fallback numbers.

Powerpack intelligently manages your numbers and ensures that your messages are delivered.

But what if you want to go deeper and specify rules for messages that are being terminated in the recipient’s carrier network?

In recent months, we’ve experienced a huge shift in the messaging landscape as major US carriers roll out their 10DLC routes to support higher messaging speeds and better deliverability for application-to-person (A2P) communication. And while 10DLC comes with a number of benefits, including higher SMS message volumes, lower costs than short codes, and better deliverability, 10DLC routes also incur surcharges, on top of the existing termination fees. Businesses may find it more cost-effective to send messages on toll-free numbers (source numbers that incur no surcharge in the AT&T network, for example), and may want to prioritize toll-free numbers whenever traffic is being terminated to users who have AT&T.

Similarly, the Verizon network issues surcharges for A2P messages on both long codes and toll-free numbers. The costs for each are similar, so a business might take other things into consideration, such as throughput rates and deliverability. 10DLC routes for long codes are sanctioned by mobile carriers and therefore are not subject to the same strict filtering as toll-free numbers, meaning they have better deliverability. In this case, a business might set long codes as Priority 1 under the Verizon network in their Powerpack. These kinds of adaptive elements means that Plivo customers have a ton more flexibility when configuring their Powerpack, and can tailor it to their specific use cases and business needs.

We recommend that all Plivo customers leverage Powerpack to reach large lists of users with just a single API request. Want to learn more? You can get the full story on how to configure a Powerpack, send outbound messages, specify priorities by carrier, and more in our Powerpack documentation.

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

Your company has settled on Plivo to handle its voice and messaging communications, and now it’s your job to start integrating Plivo into your company’s applications. Don’t worry — Plivo has an SDK to help you out. Let’s see how to make outbound calls and handle incoming calls through PHLO.

Install the Plivo SDK

We’ll presume you already have your Node.js environment set up. Change to the directory into which you want to install the Plivo Node.js SDK and run

$ npm i plivo

Find your Auth ID and Auth Token

You have to have proper credentials before you can use the Plivo API. We provide an Auth ID and Auth Token in the Account section at the top of the overview page of the Plivo console.

Choose a phone number

You need an voice-enabled Plivo phone number if you want to receive incoming calls. Check the Numbers screen of the Plivo console to see what numbers you have available. You can also rent numbers from this screen.

Use PHLO to set up an outbound call

Now you can turn to PHLO, Plivo’s visual workflow design studio, to set up the workflow for an outbound call. Click on the PHLO icon on the left-side navigation bar, then on Create New PHLO. In the window that pops up, click Build My Own.

Let’s start with a very simple workflow. From the list of components on the left side, drag and drop the Initiate Call component onto the canvas, then connect the Start node to the Initiate Call node using the API Request trigger state.

Now you can add configuration information for the call in the right pane. Valid phone numbers begin with a plus sign and a country code. Add a caller ID number in the From field and a destination number in the To field, then click Validate to save the configuration.

PHLO lets you use variables for From and To values, but we’re keeping it simple for this example.

Now drag the Play Audio component onto the canvas. Connect the Initiate Call node to Play Audio using the Answered trigger state. In the Configuration panel, enter the text you want to play for the call recipient, then click Validate.

That’s all we’re going to do for now — we told you it was simple. Give the PHLO a name by clicking on the pencil icon in the upper left, then click the Save button in the upper right.

Run the PHLO to make a call

Now you can trigger the PHLO and test it out. Copy the PHLO ID from the end of the URL of the workflow you just created. You’re also going to need your Auth ID and Auth Token. Create a file — let’s call it TriggerPhlo.js — and paste this code into it:

1
2
3
4
5
6
7
8
9
10
11
12
13
var plivo = require('plivo');
var PhloClient = plivo.PhloClient;
var authId = '<auth_id>';
var authToken = '<auth_token>';
var phloId = '<PHLO_ID>';
var phloClient = phlo = null;

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

Substitute actual values for <auth_id>, <auth_token>, and <PHLO_ID>. Save the file and run it with the commandBoom — you’ve made an outbound call.

$ node TriggerPhlo.js

Set up inbound calls

Of course outbound calls are only half of the equation. Plivo supports inbound calls as well. To see how, let’s create another PHLO and again specify Build My Own. This time, drag the Play Audio component onto the canvas and connect the Start node to it using the Incoming Call trigger state. In the Configuration panel, enter some text to speak to the caller when the call is answered, then click Validate to save the configuration. Give this PHLO a name, then click Save.

Before you can receive a call using this PHLO, you have to assign it to a Plivo number. Go back to the Plivo console and click on Phone Numbers on the left nav bar. From the list of Your Numbers, click on the number you want to use. On the next screen, from the Application Type dropdown, choose PHLO. From the PHLO Name dropdown, choose the PHLO you just created. Then click Update Number at the bottom of the screen.

Guess what? You’re done! You don’t have to run a program for this PHLO to work. Just call the Plivo number you specified and you should hear the message you configured read by Plivo’s text-to-speech processor.

Conclusion

And that’s all there is to sending and receiving voice calls using Plivo’s Node.js SDK. Don’t use Node.js? Don’t worry — we have SDKs for Java, Python, PHP, Ruby, .NET Core, .NET Framework, and Go.

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