[TIER-1 10DLC PROVIDER FOR PLATFORMS AND GLOBAL ENTERPRISES]

Launch 10DLC campaigns in the US in 24 hours

Get your 10DLC campaigns approved faster with the help of our A2P compliance experts, and save costs via our direct connections with all major US carriers.

Talk to an expert

Get your 10DLC campaigns approved within a day

Tier-1 connections with all major carriers

Our direct connections to all major US carriers remove the risks of registering through intermediaries, eliminating delays for your customers.

A dedicated team of compliance experts

Let our in-house experts help you manage 10DLC compliance. You will also get tailored guidance to navigate A2P regulations easily.

Scalability and throughput you can rely on

With us at your side, you can manage high message volumes without compromising quality and scale your operations quickly.

Leverage the compliance expertise of a CPaaS leader

Navigating US compliance laws for A2P can be challenging, especially since each campaign has unique requirements. We’re here to help you:

• Ensure your 10DLC campaigns meet all the necessary conditions
• Reduce the risk of rejections
• Go live faster

Juniper Research Top CPaaS Vendor

Infobip named as established leader second year in a row

2024 Gartner® Magic Quadrant™ for CPaaS

Infobip named a leader

Metrigy CPaaS MetriRank report

Infobip takes top spot

Leader for CpaaS 2023

Industry CPaaS leader

Quick 10DLC registration over our web platform or API

Complete the entire 10DLC registration process via our web platform or API, and go live with SMS, MMS, and Voice campaigns in a day.

		OkHttpClient client = new OkHttpClient().newBuilder()
    .build();
MediaType mediaType = MediaType.parse(“application/json”);
RequestBody body = RequestBody.create(mediaType, “{\”reason\”:\”Example appeal reason\”}”);
Request request = new Request.Builder()
    .url(“https://{baseUrl}/number-registration/1/campaigns/{campaignId}/appeal”)
    .method(“POST”, body)
    .addHeader(“Authorization”, “{authorization}”)
    .addHeader(“Content-Type”, “application/json”)
    .addHeader(“Accept”, “application/json”)
    .build();
Response response = client.newCall(request).execute();
							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10
											11
											12

		curl -L -g ‘https://{baseUrl}/number-registration/1/campaigns/{campaignId}/appeal’ \
-H ‘Authorization: {authorization}’ \
-H ‘Content-Type: application/json’ \
-H ‘Accept: application/json’ \
-d ‘{
  “reason”: “Example appeal reason”
}’

							
											1
											2
											3
											4
											5
											6
											7
											8

		var options = new RestClientOptions(“”)
{
    MaxTimeout = -1,
};
var client = new RestClient(options);
var request = new RestRequest(“https://{baseUrl}/number-registration/1/campaigns/{campaignId}/appeal”, Method.Post);
request.AddHeader(“Authorization”, “{authorization}”);
request.AddHeader(“Content-Type”, “application/json”);
request.AddHeader(“Accept”, “application/json”);
var body = @”{“”reason””:””Example appeal reason””}”;
request.AddStringBody(body, DataFormat.Json);
RestResponse response = await client.ExecuteAsync(request);
Console.WriteLine(response.Content);
							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10
											11
											12
											13

		package main

import (
    “fmt”
    “strings”
    “net/http”
    “io/ioutil”
)

func main() {

    url := “https://{baseUrl}/number-registration/1/campaigns/{campaignId}/appeal”
    method := “POST”

    payload := strings.NewReader(`{“reason”:”Example appeal reason”}`)

    client := &http.Client {
    }
    req, err := http.NewRequest(method, url, payload)

    if err != nil {
        fmt.Println(err)
        return
    }
    req.Header.Add(“Authorization”, “{authorization}”)
    req.Header.Add(“Content-Type”, “application/json”)
    req.Header.Add(“Accept”, “application/json”)

    res, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer res.Body.Close()

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(body))
}
							
											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
											40
											41
											42

		import http.client
import json

conn = http.client.HTTPSConnection(“{baseUrl}”)
payload = json.dumps({
    “reason”: “Example appeal reason”
})
headers = {
    ‘Authorization’: ‘{authorization}’,
    ‘Content-Type’: ‘application/json’,
    ‘Accept’: ‘application/json’
}
conn.request(“POST”, “/number-registration/1/campaigns/{campaignId}/appeal”, payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode(“utf-8”))
							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10
											11
											12
											13
											14
											15
											16

		<?php

$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => ‘https://{baseUrl}/number-registration/1/campaigns/{campaignId}/appeal’,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => ”,
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 0,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => ‘POST’,
    CURLOPT_POSTFIELDS =>‘{“reason”:”Example appeal reason”}’,
    CURLOPT_HTTPHEADER => array(
        ‘Authorization: {authorization}’,
        ‘Content-Type: application/json’,
        ‘Accept: application/json’
    ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $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

		var settings = {
    “url”: “https://{baseUrl}/number-registration/1/campaigns/{campaignId}/appeal”,
    “method”: “POST”,
    “timeout”: 0,
    “headers”: {
        “Authorization”: “{authorization}”,
        “Content-Type”: “application/json”,
        “Accept”: “application/json”
    },
    “data”: JSON.stringify({
        “reason”: “Example appeal reason”
    }),
};

$.ajax(settings).done(function (response) {
    console.log(response);
});
							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10
											11
											12
											13
											14
											15
											16
											17

		var https = require(‘follow-redirects’).https;
var fs = require(‘fs’);

var options = {
    ‘method’: ‘POST’,
    ‘hostname’: ‘{baseUrl}’,
    ‘path’: ‘/number-registration/1/campaigns/{campaignId}/appeal’,
    ‘headers’: {
        ‘Authorization’: ‘{authorization}’,
        ‘Content-Type’: ‘application/json’,
        ‘Accept’: ‘application/json’
    },
    ‘maxRedirects’: 20
};

var req = https.request(options, function (res) {
    var chunks = [];

    res.on(“data”, function (chunk) {
        chunks.push(chunk);
    });

    res.on(“end”, function (chunk) {
        var body = Buffer.concat(chunks);
        console.log(body.toString());
    });

    res.on(“error”, function (error) {
        console.error(error);
    });
});

var postData = JSON.stringify({
    “reason”: “Example appeal reason”
});

req.write(postData);

req.end();
							
											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

		require “uri”
require “json”
require “net/http”

url = URI(“https://{baseUrl}/number-registration/1/campaigns/{campaignId}/appeal”)

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request[“Authorization”] = “{authorization}”
request[“Content-Type”] = “application/json”
request[“Accept”] = “application/json”
request.body = JSON.dump({
    “reason”: “Example appeal reason”
})

response = https.request(request)
puts response.read_body

							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10
											11
											12
											13
											14
											15
											16
											17
											18
											19
											20

BUY A 10DLC NUMBER

To start, you first need to buy a dedicated 10DLC number. You can buy a new one or import an existing one.

REGISTER YOUR BRAND

Provide the necessary information about your brand through our easy-to-use automated tool, which you only need to do once.

REGISTER YOUR CAMPAIGN

When registering campaigns, you need to provide details about the types of messages you want to send for each campaign.

GO LIVE WHEN APPROVED

Our experts will review the provided details. Once we confirm your campaigns align with messaging guidelines, you can start immediately.

Automate 10DLC campaign management with CPaaS X

CPaaS X is a fully automated, full-stack API solution designed for platforms. It reduces operational work by handling everything through APIs, from registering campaigns to sending traffic and receiving reports.

Streamlined onboarding

CPaaS X provides clear documentation and API access, making onboarding swift and efficient.

Faster time-to-market

With CPaaS X, you can launch clients campaigns in 24 hours or less. This lets your customers capitalize on marketing opportunities quickly and engage their audience faster.

Real-time analytics

CPaas X’s analytics and reporting tools offer real-time insights into campaign performance, enabling you to easily optimize 10DLC campaigns for your clients and showcase their value.

Omnichannel with ease

Use a single API to manage multiple channels and configure automatic channel switches (failover logic) with ease.

Discover more about CPaaS X

Matthew McRoberts
Senior Vice President, Global Alliances

Frequently asked questions about 10DLC campaigns

General information about 10DLC

What is 10DLC?

10DLC stands for 10-Digit Long Code, a system allowing businesses to send sanctioned Application-to-Person (A2P) messaging traffic over local phone numbers, providing a compliant, reliable, and cost-effective for business messaging.

What are the benefits of using 10DLC?

Benefits of 10DLCs include improved message deliverability, higher throughput rates, lower costs compared to short codes, and compliance with carrier regulations, ensuring messages reach intended recipients.

When to use a 10DLC instead of a short code?

Use 10DLCs if you want to:

Send SMS or MMS messages to customers and enable voice calls
Focus on local customers (e.g., one state)
Start faster, with less cost

Use dedicated short codes if you want to:

Send large volumes of SMS or MMS messages nationwide, at high speeds (time-critical)
Have a short, recognizable number for your brand
Track delivery receipts (DLRs)

Learn more about the differences between 10DLC, short codes and toll-free numbers here.

What is a use case in the context of 10DLC?

A use case, or campaign, refers to the reason for sending messages, such as marketing, customer care, notifications, or two-factor authentication (2FA).

Can I use the same number for multiple use cases?

No, each number can only be associated with one campaign at a time. However, a campaign can have multiple numbers assigned to it.

What is throughput, and how is it determined?

Throughput is the rate at which messages can be sent. It is determined by the brand’s verification status and the type of campaign, with higher verification scores allowing higher throughput rates.

10DLC registration

Why do businesses need to register for 10DLC?

Registration is required to comply with carrier regulations, improve message deliverability, and prevent messages from being marked as spam. It ensures that the business’s identity and messaging purpose are verified. You can read more about 10DLC registration here.

What is The Campaign Registry (TCR)?

TCR is an organization that works with mobile carriers to manage the registration of A2P messaging campaigns. It ensures that businesses sending messages are verified and compliant with industry standards.

What information is needed for 10DLC registration?

Businesses need to provide their EIN, business address, website, business type, details on how they use text messaging, and consent mechanisms for recipients.

How do I register for 10DLC?

Registration can be done through Infobip by submitting the required business and campaign information. The process involves both brand and campaign verification and can take a few days to a couple of weeks. Learn more about the 10DLC registration process here.

What happens if I don’t register for 10DLC?

Unregistered messages may be blocked or throttled by carriers, and businesses might face additional surcharges. Compliance with registration is mandatory to avoid these penalties.

How can I minimize downtime during the 10DLC registration process?

Ensure your campaign is approved before porting numbers from another carrier, and coordinate with your current carrier to remove campaigns from their system before switching.

Can non-US entities register for 10DLC?

Yes, non-US entities can register for 10DLC, but they must comply with the same rules and face similar penalties as US-based entities.

How does brand vetting affect 10DLC registration?

Brand vetting, which provides a vetting score, is recommended for higher throughput and complex campaign use cases. It helps in achieving better messaging performance and compliance.

What are the costs associated with 10DLC registration?

Costs include fees for brand and campaign registration, ongoing compliance fees, and potential fines for non-compliance. These fees vary by provider and carrier.

How long does the 10DLC registration process take?

The process can take anywhere from one day to a couple of weeks, depending on the complexity and accuracy of the information provided. Due to Infobip’s status as a Tier-1 10DLC provider, the process can be quick and last one day.

How do I register my brand with Infobip for 10DLC?

Log into the Infobip Dashboard, select Campaigns, and follow the prompts to register your brand and campaigns. Ensure all required information is accurate to avoid delays.

What steps are involved in Infobip’s 10DLC registration?

Infobip requires businesses to submit detailed information about their brand and use cases through their platform. Infobip’s experts then validate the campaigns to align with messaging guidelines, and once approved by Infobip, messaging can begin.

10DLC compliance

What are the compliance requirements for 10DLC?

Key requirements for 10DLC compliance include:

obtaining prior express written consent from recipients
ensuring opt-in and opt-out processes
providing accurate business and campaign information during registration
including the company name in the first message
following messaging guidelines to prevent spam and adhering to industry best practices

What are the non-compliance penalties for 10DLC?

Penalties can include fines, message blocking, and throttling by carriers. Specific fines can vary based on the type of violation and carrier policies.

Launch your 10DLC campaigns in
24 hours

Reach out to our experts to begin the
approval process for 10DLC and gain a
competitive advantage by acting quickly.

Contact an expert