Powerpack

The use of 10-digit phone numbers (long codes) for SMS and MMS messages is heavily regulated in the US and Canada. Long codes, however, remain the medium of choice for businesses seeking to engage with their customers via SMS. A long code is more familiar to customers, has a price advantage, and is easily procured. As a result, long codes are the natural choice for most use cases.

Powerpack makes message communication using long codes effective and reliable at scale. It is designed to meet your overall message throughput and volume requirements, regardless of the size of your business.

By automatically distributing your overall message traffic across a pool of source numbers, Powerpack keeps you compliant with the per-day and per-second throughput guidelines defined by the Cellular Telecommunications Industry Association (CTIA).

Features of Powerpack

• Number Pooling: Powerpack intelligently distributes your outbound message traffic over a pool of source numbers to optimize your overall message volumes.
• Sticky Sender: Sticky Sender helps maintain a single thread of conversation by sending messages to a subscriber from the same source number in the pool.
• Local Connect: Local Connect helps prioritize phone numbers in the pool that belong to the region and/or area code of the subscriber.
• Number Pool Refresh: Powerpack keeps your pool of numbers healthy by automatically replacing phone numbers that have a poor delivery rate.
• Auto Traffic Distribution: Powerpack evenly distributes your outbound message traffic across the available phone numbers in your number pool.
• Source Number Queuing: A dedicated rate-limiting queue per source number ensures that you never exceed the per-number message sending rates applicable in the US and Canada.

Introduction to Powerpack

Though the US and Canada heavily regulate SMS/MMS messages sent using regular 10-digit phone numbers, these long codes remain the medium of choice for businesses that wish to engage with their customers via messaging. The familiarity that they lend to a conversation, their price advantage, and the easy procurement process make long codes a natural choice for most users.

Powerpack makes message communication using long codes effective and reliable at scale. It’s designed to meet large-scale messaging throughput and volume requirements. By automatically distributing your overall message traffic across a pool of source numbers, Powerpack keeps you compliant with per-day and per-second throughput limits as defined by the CTIA (Cellular Telecommunications Industry Association).

Product features

1. Number pool — Powerpack intelligently distributes your outbound message traffic over a pool of source numbers optimal for your overall message volumes. It takes only a few seconds to set up a pool of source numbers that’s just right for your message volume.
2. High deliverability — Powerpack provides high deliverability by intelligently managing your numbers. Powerpack provides intelligent load management and eliminates any single point failure.
3. Regulatory compliance — Messaging regulatory compliance varies not only by number type but often by location. Powerpack builds in a consolidated set of compliance controls that enhance deliverability and throughput.
4. Sticky Sender — If you wish to contact the same subscriber more than once, Powerpack can help maintain a single conversation thread by always sending messages to the subscriber from the same source number in the pool.
5. Local Connect — Continuing to personalize your message communication, Local Connect prioritizes phone numbers in the pool that match the region and/or area code of the subscriber.
6. Automatic fallback — You can enable automatic fallback by adding Plivo toll-free or short code numbers to your Powerpacks. Toll-free and short code numbers are better options than long codes for application-to-person (A2P) messages sent at high scale. Powerpack can switch from one number type to another without any delivery loss.

Creating a new Powerpack

To create a new Powerpack:

1. Log in to the Plivo console and navigate to Messaging > Powerpacks, then click Add New Powerpack.
2. In the Details section, enter a name for the Powerpack.
3. Enable Sticky Sender if you want to maintain a single thread of conversation by ensuring that messages sent to a particular number are always sent from the same Powerpack source number. Enabling or disabling Sticky Sender is reflected in the source number resolution logic instantaneously.
4. Enable Local Connect if you want to ensure that Powerpack prioritizes using a source number belonging to the same region or area code as the destination number for outbound SMS and MMS messages. Enabling or disabling Local Connect is reflected in the source number resolution logic instantaneously.
5. Under the Application Configuration settings, select the application type and name from the respective drop-downs.
6. Under Long Codes, in the Number Pool section, enter the count of phone numbers at a country and/or regional level.
   • To configure your number pool at a country level, enter your daily message volume for the US and Canada. Plivo will recommend the optimal phone number pool size based on your input.
   • To configure your number pool at an area code or region level, use the Advanced Settings tab to add phone numbers to the number pool at a more granular level.
   • If you don’t need to get more granular than state-level region matching, simply specify the total count of numbers against any prefix from that state.
7. Specify the pool size, and click Add Powerpack to initiate the purchasing and provisioning of phone numbers.

Sending outbound messages

To send messages using Powerpack:

1. Log in to the Plivo console and navigate to Messaging > Powerpacks to view all of your Powerpacks.

2. Copy the Powerpack ID for the Powerpack you wish to use.

   

3. Enter the Powerpack ID for powerpack_uuid in the Send SMS API request.

Code samples

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

Updating a Powerpack

To modify or update your Powerpack

1. Log in to the Plivo console and navigate to Messaging > Powerpacks to view all of your Powerpacks.
2. Select the Powerpack you wish to modify or update.
3. In the Properties section, modify Sticky Sender by enabling or disabling it, then click Update.
4. In the Properties section, modify Local Connect by enabling or disabling it, then click Update.

5. To manually remove phone numbers from your number pool, first click on View Numbers.

   

6. Select Delete & Unrent for the numbers you wish to remove from your number pool.

Receiving incoming messages

Plivo Applications can handle all incoming messages to the Powerpack phone numbers. To create a new Plivo Application, navigate to Messaging > Applications on the console and click Add New Application. Once created, you can associate this application with your Powerpack.

Once you configure an Application for your Powerpack, all incoming messages to your Powerpack phone numbers are posted to the message_url in your Plivo Application.

1. In the application settings, modify the application by selecting the type and name from the respective drop-downs.
2. The Number Pool Composition section displays the total count of phone numbers in the number pool for each country.
   • To update your number pool composition at a country level, update the number count for the country and click Update.
   • To update your number pool composition at an area code or region level, go to the Advanced Settings tab, update the number count for the region or area code, and click Update.
3. If you are increasing the pool size, a dialogue box will prompt you to confirm the purchase of new numbers.

Local Connect

Local Connect is designed to make message communication personal. It ensures that messages get sent using a local phone number with the same area code or regional prefix as the destination number.

How Region-Based Source Number Resolution Works in Local Connect

Let’s look at an example of how this works. Suppose you’re sending an SMS/MMS message to a San Francisco number beginning with area code 415:

• If a phone number with prefix 415 is present in the number pool, Powerpack will use it to send the outbound SMS/MMS.
• If a phone number with a 415 prefix is not found in the number pool, or if all the phone numbers with 415 prefixes in the pool have already been used to recommended capacity (150 messages/day), Powerpack will deliver the message through any other phone number of the same region as the destination number (in this case, California).
• If no phone numbers of the same region are found in the Powerpack, the message will be sent via a random US phone number.
• If no US phone numbers are found in the pool, the message will be sent via a Canadian number.

How to specify automatic fallback for SMS and MMS in Powerpack

You can add short code, toll-free, and long code numbers to your Powerpack. When you add more than one type of number to a Powerpack, the Powerpack automatically resolves the source numbers of various types based on the number available and priorities set within the Powerpack to help you achieve the best delivery rate.

The default fallback priority list, which you can customize in the console, is:

These default values can also be changed based on your needs from the console. For example, if you want to maximize cost savings, you can set the following priorities for the US and Canada.

We recommend having long code numbers and toll-free numbers in your Powerpack, with long codes prioritized over toll-free numbers. The number of long codes in your Powerpack is an important factor for sending messages on a large scale. That number should be based on your average message traffic volume and our number pool size recommendation. We request that you stick to the recommended set of numbers.

Operator configurations for SMS and MMS

Operator configurations allow you to select the type of source number, such as short code or toll-free, with which to send a message to specific operator terminating numbers. They are currently available only for Verizon and AT&T operators.

In the example below, all Verizon terminating numbers are set to be routed via short code.

This feature can help you overcome message delivery failure with certain operators and increase delivery rates. Visit the console to get started with this feature.

Add a toll-free number to a Powerpack

Combining toll-free numbers in the Powerpack helps in two major ways.

1. Run multiregion message business campaigns: Toll-free numbers support delivery at a larger scale. Combining this scaling capability with Powerpack gives you increased availability and high-scale deliverability.
2. Reach networks not supported by your toll-free numbers: Even though toll-free numbers can reach most destination networks, there might be some networks that don’t support them. In these instances, Powerpack intelligently falls back to using other numbers in the pool.

For example: If you send messages to destination networks C1 and C2 using Powerpack, but C2 doesn’t support toll-free numbers, Powerpack will use other numbers in the pool to send messages to the C2 network and short code numbers to reach customers in C1.

To use toll-free numbers with Powerpack:

• To add a toll-free number to your Powerpack, go to the Powerpack page in the console and add a toll-free number.
• You may add only one toll-free number to a Powerpack.
• Once you’ve added a toll-free number to your Powerpack, Plivo will use that number to send an outbound message if the destination network and country support toll-free messaging. Otherwise, Powerpack will fall back to using other numbers in the number pool.