Announcing Powerpack for Improved SMS Delivery

Plivo makes it simple for businesses to send SMS text messages.  With a couple of lines of code, your application is ready to start sending messages to more than 190 countries. On average, our customers send out their first text message within 15 minutes of signing up.

The complexities of SMS messaging may surface once you start sending a high volume of messages. At that point you may face challenges such as managing country-specific restrictions, per-source-number SMS limits, and daily SMS volumes. You may have to write additional software logic to manage such complexities to ensure high SMS delivery rates.

To help our customers improve SMS delivery and go live faster for high-scale messaging use cases, we’re releasing Powerpack for SMS, a bundle of features that makes message communication at scale more effective and reliable. Powerpack ensures that your SMS messages get delivered at whatever scale you’re sending them, to any country.

How Powerpack helps

Powerpack provides several features that help high-volume messaging customers.

Number pools for easy scaling

With Powerpack, you construct a pool of source numbers optimal for your daily volume and peak send rate. Your messages are automatically distributed across this source number pool. All you have to do is specify the Powerpack’s unique identifier in the Send SMS API request.

You can add more numbers to your Powerpack number pool in seconds, right from your Plivo console. This lets you scale infinitely without having to make any code changes.

Sticky sender for a consistent experience

To ensure that your end users always receive messages from the same source number, Powerpack establishes a sticky mapping between the recipient’s number and the source number used from the Powerpack for the first text message to that recipient. This stickiness enables two-way conversations by keeping the conversation thread on the recipient’s handset intact.

Smart queuing for carrier compliance

Powerpack maintains an internal rate-limiting queue for every source number in the pool and sends messages to downstream carriers at a rate that’s compliant with industry-defined best practices. Source number-specific rate-limiting queues, in conjunction with Powerpack’s message distribution logic, ensure you meet your overall volume and throughput requirements while staying compliant with per-number limits.

Local connect for higher open rates

Powerpack prioritizes source numbers in the pool that are from the same geographic region as the destination number. The highest priority is given to numbers of the same area code, followed by those in the same state, then country.

For example, when sending an SMS to a San Francisco number that starts with area code 415, Powerpack will use a number in the pool that begins with +1-415. If no +1-415 numbers are found in the pool, Powerpack will use an available California state number to send the message.

The Powerpack management UI in the console allows you to provision number pools and all the other features with a few clicks.

Getting started with Powerpack

Getting started with Powerpack is easy. Log in to the Plivo console and click to Messaging > Powerpack. Follow the instructions on the console to create a new Powerpack.

To send messages with your newly created Powerpack, invoke Plivo’s Send SMS API with the powerpack_uuid request parameter set to the Powerpack’s UUID.

1
2
3
4
5
6
7
8
import plivo

client = plivo.RestClient('<auth_id>','<auth_token>')
message_created = client.messages.create(
    powerpack_uuid='<powerpack_uuid>',
    dst='<destination_number>',
    text='Test Message'
)

1
2
3
4
5
6
7
8
9
10
11
12
13
require 'rubygems'	
require 'plivo'	

include Plivo	

client = RestClient.new("<auth_id>","<auth_token>")
response = client.messages.create(	
  nil,	
  [destination_number],	
  'Test Message',	
  powerpack_uuid: '<powerpack_uuid>'	
)	
puts response

1
2
3
4
5
6
7
8
9
10
let plivo = require('plivo');
let client = new plivo.Client('<auth_id>','<auth_token>');

client.messages.create({
  powerpackUUID:"<powerpack_uuid>",
  dst:'<destination_number>',
  text: 'Test Message',
},).then(function (message_created) {
  console.log(message_created)
})

1
2
3
4
5
6
7
8
9
10
11
12
13
require 'vendor/autoload.php';	
use Plivo\RestClient;	

$client = new RestClient('<auth_id>', '<auth_token>');	
$message_created = $client->messages->create(
    [  
            "powerpack_uuid" => "<powerpack_uuid>",
            "dst" => "<destination_number>",
            "text"  =>"Hello, this is a sample text",
            "url"=>"https://<yourdomain>.com/sms_status/",
    ]
);
print_r($message_created);

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.plivo.api;

import com.plivo.api.models.message.Message;
import com.plivo.api.exceptions.PlivoRestException;
import java.io.IOException;
import java.util.Collections;

class Example {
  public static void main(String[] args) throws IOException, PlivoRestException {
    Plivo.init("<auth_id>", "<auth_token>");
    Message.creator("<powerpack_uuid>","<destination_number>"), "Test Message").create();
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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
	}
	client.Messages.Create(plivo.MessageCreateParams{
		PowerpackUUID: "<powerpack_uuid>",
		Dst:           "<destination_number>",
		Text:          "Test Message",
	})
}

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

internal class Program	
{	
    public static void Main(string[] args)	
    {	
        var api = new PlivoApi("<auth_id>","<auth_token>");	
        var response = api.Message.Create(	
            powerpack_uuid:"<powerpack_uuid>",	
            dst:new List<String>{"<destination_number>"},	
            text:"Test Message"	
        );	
        Console.WriteLine(response);	
    }	
}	

Your message will be sent via one of the phone numbers in the Powerpack number pool.

For more information, visit our Powerpack documentation.

Pricing

Powerpack is enabled on your account at no extra cost. You pay only for actual text messages sent and received.

Upcoming enhancements

We’re actively working on additional Powerpack features. Some of the enhancements planned for the coming months include:

Alphanumeric sender IDs: Many countries allow using brand names and keywords as sender IDs. Soon, customers will have the option to configure Powerpack to use alphanumeric sender IDs for SMS messages to these countries.

Powerpack management APIs: We’re working on APIs to create new Powerpacks and manage number pools programmatically.

Content optimization features: We’re also working on features to better manage the content of your text messages based on country-specific support for characters sets and message length.

Not yet using Plivo? Getting started takes just five minutes. Sign up today.