How to Send SMS in .NET Using Plivo's SMS API

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 send and receive messages through Plivo in a .NET Core application.

Install the Plivo SDK

We’ll presume you already have .NET Core and .NET CLI installed. Change to the directory into which you want to install the Plivo .NET Core SDK and run

$ dotnet new console
$ dotnet add package Plivo --version 4.15.1

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 your Plivo Console.

Find Your Auth Credentials on Plivo Console

Choose a phone number

You need an SMS-enabled Plivo phone number to send messages to the US and Canada. Check the Numbers screen of your Plivo console to see what numbers you have available and which of them support SMS capabilities. You can also buy numbers from this screen.

Buy a New Plivo Number

SMS regulations followed by carriers vary from country to country. For messages to countries other than the US and Canada, you might want to register an alphanumeric sender ID for your messages. You can learn more about the use of alphanumeric sender ID and register one from your Plivo Console.

Send an SMS message

Now you’re ready to start. Open the file Program.cs in the CS project and paste in 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: "+14156667777",
                dst: new List<String> { "+14156667778" },
                text: "Hello, this is test message"
                );
            Console.WriteLine(response);
        }
    }
}

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 a phone number using the Sandbox Numbers page of the Console.

Save the file and use the below command to run it.

$ dotnet run

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 app. Plivo will send the message along with other parameters to your Message URL.

Begin by setting up a .NET Core app. Create a project directory with the command

$ mkdir receivesmsapp

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

$ dotnet new mvc --no-https

Then install the Plivo .NET package with the command

$ dotnet add package Plivo --version 4.15.1

Change to the Controllers directory under the receivesmsapp directory. Create a Controller called ReceiveSmsController.cs and paste in 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 which 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 app you have to update Properties/launchSettings.json by setting the applicationUrl as

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

Then start the local server with the command

$ dotnet run

You should 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.

Sample ngrok CLI

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 .NET Core SDK. Don’t use .NET Core? Don’t worry — we have SDKs for Java, Python, PHP, Node.js, Ruby, .NET Framework, and Go.

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

comments powered by Disqus