Sending High Volume SMS

POST /restapi/v1.0/account/~/a2p-sms/batches
Content-Type: application/json
Accept: application/json

{
  "from": "+16505550100",
  "text": "Hello Team",
  "messages": [
    { "to": ["+14155550100"] },
    { "to": ["+12125550100"] }
  ]
}

const RC = require('@ringcentral/sdk').SDK

// Instantiate the SDK and get the platform instance
var rcsdk = new RC({
    server: "https://platform.ringcentral.com",
    clientId: "RC_APP_CLIENT_ID",
    clientSecret: "RC_APP_CLIENT_SECRET"
});
var platform = rcsdk.platform();

/* Authenticate a user using a personal JWT token */
platform.login({ jwt: "RC_USER_JWT" })

// For the purpose of testing the code, we put the recipient number in the variable.
// Feel free to set the recipient number directly.
var RECIPIENT = "RECIPIENT-PHONE-NUMBER"

platform.on(platform.events.loginSuccess, function(e){
    read_extension_phone_number_detect_a2psms_feature()
});

platform.on(platform.events.loginError, function(e){
    console.log("Unable to authenticate to platform. Check credentials.", e.message)
    process.exit(1)
});

/*
  Read phone number(s) that belongs to the authenticated user and detect if a phone number
  has the A2P SMS capability
*/
async function read_extension_phone_number_detect_a2psms_feature(){
  try {
      let endpoint = "/restapi/v1.0/account/~/extension/~/phone-number"
      var resp = await platform.get(endpoint)
      var jsonObj = await resp.json()
      for (var record of jsonObj.records){
          for (feature of record.features){
              if (feature == "A2PSmsSender"){
                // If a user has multiple phone numbers, check and decide which number
                // to be used for sending text message.
                return await send_batch_sms(record.phoneNumber)
              }
          }
      }
      if (jsonObj.records.length == 0)
        console.log("This user does not own a phone number!")
      else
        console.log("None of this user's phone number(s) has A2P SMS capability!")
  } catch(e) {
      console.log(e.message)
  }
}

/*
 Broadcast a text message from a user own phone number to multiple recipients
*/
async function send_batch_sms(fromNumber) {
    try{
        let bodyParams = {
            from: fromNumber,
            text: "Hello Team",
            messages: [
                { to: [RECIPIENT] },
              // Adding more recipients
              /*
              { to: [ "Recipient-2-Phone-Number" ] },
              { to: [ "Recipient-N-Phone-Number" ] }
              */
            ]
        }
        let endpoint = "/restapi/v1.0/account/~/a2p-sms/batches"
        var resp = await platform.post(endpoint, bodyParams)
        var jsonObj = await resp.json()
        console.log("Batch sent. Batch id: " + jsonObj.id)
        check_batch_status(jsonObj.id)
    }catch(e){
        console.log(e.message)
    }
}

/*
 Send a batch from a user own phone number to multiple recipient with personalized message
*/
async function send_personalized_sms(fromNumber) {
    try{
        let bodyParams = {
            from: fromNumber,
            // This text becomes the default text and can be obmitted, if the text in a recipient object is not specified, this text will be used
            text: "Hello Team",
            messages: [
                { to: [RECIPIENT], text: "Hello Alice" },
              // Adding more recipients
              /*
              { to: [ "Recipient-2-Phone-Number" ], text: "Hello Bob" },
              { to: [ "Recipient-N-Phone-Number" ], text: "Hola Maria" }
              */
            ]
        }
        let endpoint = "/restapi/v1.0/account/~/a2p-sms/batches"
        var resp = await platform.post(endpoint, bodyParams)
        var jsonObj = await resp.json()
        console.log("Batch sent. Batch id: " + jsonObj.id)
        check_batch_status(jsonObj.id)
    }catch(e){
        console.log(e.message)
    }
}

/*
 Check the batch status until it's completed.
 Sending a large batch will take some time for the server to complete. You can read a batch status using the batch id returned in the response after sending a batch.
*/
async function check_batch_status(batchId){
  try {
      let endpoint = `/restapi/v1.0/account/~/a2p-sms/batches/${batchId}`
      let resp = await platform.get(endpoint);
      let jsonObj = await resp.json()
      console.log("Batch status: ", jsonObj.status)
      if (jsonObj.status != "Completed"){
        await sleep (5000);
        check_batch_status(jsonObj.id);
      }else{
        console.log(jsonObj)
      }
  } catch (e) {
    console.log(e.message)
  }
}

const sleep = async (ms) => {
  await new Promise(r => setTimeout(r, ms));
}

import time, json
from ringcentral import SDK

# Read phone number(s) that belongs to the authenticated user and detect if a phone number
# has the A2P SMS capability
def read_extension_phone_number_detect_a2psms_feature():
    try:
        endpoint = "/restapi/v1.0/account/~/extension/~/phone-number"
        resp = platform.get(endpoint)
        jsonObj = resp.json()
        for record in jsonObj.records:
            for feature in record.features:
                if feature == "A2PSmsSender":
                    # If a user has multiple phone numbers, check and decide which number
                    # to be used for sending A2P SMS message.
                    return send_batch_sms(record.phoneNumber)

        if jsonObj.records.count == 0:
            print ("This user does not own a phone number!")
        else:
            print ("None of this user's phone number(s) has the A2P SMS capability!")
    except Exception as e:
        print (e)

#
# Broadcast a text message from a user own phone number to multiple recipients
#
def send_batch_sms(fromNumber):
    try:
        bodyParams = {
            'from': fromNumber,
            'text': "Hello Team",
            'messages': [
                { 'to': [RECIPIENT] }
            # Adding more recipients
            #   { 'to': [ "Recipient-2-Phone-Number"] },
            #   { 'to': [ "Recipient-N-Phone-Number"] }
            #
            ]
        }
        endpoint = "/restapi/v1.0/account/~/a2p-sms/batches"
        resp = platform.post(endpoint, bodyParams)
        jsonObj = resp.json()
        print ("Batch sent. Batch id: " + jsonObj.id)
        check_batch_status(jsonObj.id)
    except Exception as e:
        print (e)

#
# Send a batch from a user own phone number to multiple recipient with personalized message
#
def send_personalized_sms(fromNumber):
    try:
        bodyParams = {
            'from': fromNumber,
            # This text becomes the default text and can be obmitted, if the text in a recipient object is not specified, this text will be used
            'text': "Hello Team",
            'messages': [
                { 'to': [RECIPIENT], 'text': "Hello Alice" }
            # Adding more recipients
            #   { 'to': [ "Recipient-2-Phone-Number"], 'text': "Hello Bob" },
            #   { 'to': [ "Recipient-N-Phone-Number"], 'text': "Hola Maria" }
            #
            ]
        }
        endpoint = "/restapi/v1.0/account/~/a2p-sms/batches"
        resp = platform.post(endpoint, bodyParams)
        jsonObj = resp.json()
        print ("Batch sent. Batch id: " + jsonObj.id)
        check_batch_status(jsonObj.id)
    except Exception as e:
        print (e)


#
# Check the batch status until it's completed.
# Sending a large batch will take some time for the server to complete. You can read a batch status using the batch id returned in the response after sending a batch.
#
def check_batch_status(batchId):
  try:
      endpoint =  "/restapi/v1.0/account/~/a2p-sms/batches/" + batchId
      resp = platform.get(endpoint)
      jsonObj = resp.json_dict()
      print ("Batch status: ", jsonObj['status'])
      if jsonObj['status'] != "Completed":
          time.sleep (5)
          check_batch_status(jsonObj['id'])
      else:
          print(json.dumps(jsonObj, indent=2, sort_keys=True))
  except Exception as e:
      print (e)

# Authenticate a user using a personal JWT token
def login():
    try:
      platform.login( jwt= "RC_USER_JWT" )
      read_extension_phone_number_detect_a2psms_feature()
    except Exception as e:
      print ("Unable to authenticate to platform. Check credentials." + str(e))

# Instantiate the SDK and get the platform instance
rcsdk = SDK("RC_APP_CLIENT_ID", "RC_APP_CLIENT_SECRET", "https://platform.ringcentral.com")
platform = rcsdk.platform()

login()

# For the purpose of testing the code, we put the recipient number in the variable.
# Feel free to set the recipient number directly.
RECIPIENT = "RECIPIENT-PHONE-NUMBER"
####################################

<?php
require('vendor/autoload.php');

// Instantiate the SDK and get the platform instance
$rcsdk = new RingCentral\SDK\SDK( "RC_APP_CLIENT_ID", "RC_APP_CLIENT_SECRET", "https://platform.ringcentral.com" );
$platform = $rcsdk->platform();

/* Authenticate a user using a personal JWT token */
try {
  $platform->login(["jwt" => "RC_USER_JWT"]);
}catch (\RingCentral\SDK\Http\ApiException $e) {
  // Getting error messages using PHP native interface
  print 'Expected HTTP Error: ' . $e;
  exit ("Error message: " . $e->apiResponse->response()->error() . PHP_EOL;
}

// For the purpose of testing the code, we put the recipient number in the variable.
// Feel free to set the recipient number directly.
$RECIPIENT = "RECIPIENT-PHONE-NUMBER";

read_extension_phone_number_detect_a2psms_feature();

/*
  Read phone number(s) that belongs to the authenticated user and detect if a phone number
  has the A2P SMS capability
*/
function read_extension_phone_number_detect_a2psms_feature(){
  global $platform;
  $endpoint = "/restapi/v1.0/account/~/extension/~/phone-number";
  $resp = $platform->get($endpoint);
  $jsonObj = $resp->json();
  foreach ($resp->json()->records as $record){
    if ($record->usageType == "DirectNumber"){
      foreach ($record->features as $feature){
        if ($feature == "A2PSmsSender"){
          // If a user has multiple phone numbers, check and decide which number
          // to be used for sending batch message.
          return send_batch_sms($record->phoneNumber);
        }
      }
    }
  }
  if (count($jsonObj->records) == 0)
    exit("This user does not own a phone number!");
  else
    exit("None of this user's phone number(s) has the A2P SMS capability!");
}

/*
 Broadcast a text message from a user own phone number to multiple recipients
*/
function send_batch_sms($fromNumber) {
  global $platform, $RECIPIENT;
  try {
    $bodyParams = array(
      'from' => $fromNumber,
      'text' => "Hello Team",
      'messages' => array(
        array ('to' => array ($RECIPIENT))
        // Adding more recipients
        /*
        array ('to' => array ("Recipient-2-Phone-Number")),
        array ('to' => array ("Recipient-N-Phone-Number"))
        */
    ));
    $endpoint = "/restapi/v1.0/account/~/a2p-sms/batches";
    $resp = $platform->post($endpoint, $bodyParams);
    check_batch_status($resp->json()->id);
  } catch (\RingCentral\SDK\Http\ApiException $e) {
    exit("Message: " . $e->message . PHP_EOL);
  }
}

/*
 Send a batch from a user own phone number to multiple recipient with personalized message
*/
function send_personalized_sms($fromNumber) {
  global $platform, $RECIPIENT;
  try {
    $bodyParams = array(
      'from' => $fromNumber,
      // This text becomes the default text and can be obmitted, if the text in a recipient object is not specified, this text will be used
      'text' => "Hello Team",
      'messages' => array(
        array ('to' => array ($RECIPIENT), 'text' => "Hello Alice")
        // Adding more recipients
        /*
        array ('to' => array ("Recipient-2-Phone-Number"), 'text' => "Hello Bob"),
        array ('to' => array ("Recipient-N-Phone-Number"), 'text' => "Hola Maria")
        */
    ));
    $endpoint = "/restapi/v1.0/account/~/a2p-sms/batches";
    $resp = $platform->post($endpoint, $bodyParams);
    check_batch_status($resp->json()->id);
  } catch (\RingCentral\SDK\Http\ApiException $e) {
    exit("Message: " . $e->message . PHP_EOL);
  }
}

/*
 Check the batch status until it's completed.
 Sending a large batch will take some time for the server to complete. You can read a batch status using the batch id returned in the response after sending a batch.
*/
function check_batch_status($batchId) {
  global $platform;
  try {
      $endpoint = "/restapi/v1.0/account/~/a2p-sms/batches/".$batchId;
      $resp = $platform->get($endpoint);
      $jsonObj = $resp->json();
      print("Batch status: " . $jsonObj->status . PHP_EOL);
      if ($jsonObj->status != "Completed"){
        sleep(5);
        check_batch_status($jsonObj->id);
      }else{
        print_r (json_encode($jsonObj, JSON_PRETTY_PRINT) . PHP_EOL);
      }
  } catch (\RingCentral\SDK\Http\ApiException $e) {
    exit("Message: " . $e->message . PHP_EOL);
  }
}
?>

require 'ringcentral'

# Read phone number(s) that belongs to the authenticated user and detect if a phone number
# has the A2P SMS capability
def read_extension_phone_number_detect_a2psms_feature()
  begin
    endpoint = "/restapi/v1.0/account/~/extension/~/phone-number"
    resp = $platform.get(endpoint)
    for record in resp.body['records'] do
      for feature in record['features'] do
        if feature == "A2PSmsSender"
          # If a user has multiple phone numbers, check and decide which number
          # to be used for sending SMS message.
          return send_batch_sms(record['phoneNumber'])
        end
      end
    end
    if resp.body['records'].length == 0
      puts ("This user does not own a phone number!")
    else
      puts("None of this user's phone number(s) has the A2P SMS capability!")
    end
  rescue StandardError => e
    puts (e)
  end
end

#
# Broadcast a text message from a user own phone number to multiple recipients
#
def send_batch_sms(fromNumber)
  begin
    bodyParams = {
        'from': fromNumber,
        'text': "Hello Team",
        'messages': [
          { 'to': [RECIPIENT] }
        # Adding more recipients
        # { 'to': [ "Recipient-2-Phone-Number"] },
        #   { 'to': [ "Recipient-N-Phone-Number"] }
        #
        ]
    }

    endpoint = "/restapi/v1.0/account/~/a2p-sms/batches"
    resp = $platform.post(endpoint, payload: bodyParams)
    puts ("Batch sent. Batch id: " + resp.body['id'])
    check_batch_status(resp.body['id'])
  rescue StandardError => e
    puts (e)
  end
end

#
# Send a batch from a user own phone number to multiple recipient with personalized message
#
def send_personalized_sms(fromNumber)
  begin
    bodyParams = {
        'from': fromNumber,
        # This text becomes the default text and can be obmitted, if the text in a recipient object is not specified, this text will be used
        'text': "Hello Team",
        'messages': [
          { 'to': [RECIPIENT], 'text': "Hello Alice" }
        # Adding more recipients
        # { 'to': [ "Recipient-2-Phone-Number"], 'text': "Hello Bob" },
        #   { 'to': [ "Recipient-N-Phone-Number"], 'text': "Hola Maria" }
        #
        ]
    }

    endpoint = "/restapi/v1.0/account/~/a2p-sms/batches"
    resp = $platform.post(endpoint, payload: bodyParams)
    puts ("Batch sent. Batch id: " + resp.body['id'])
    check_batch_status(resp.body['id'])
  rescue StandardError => e
    puts (e)
  end
end

#
# Check the batch status until it's completed.
# Sending a large batch will take some time for the server to complete. You can read a batch status using the batch id returned in the response after sending a batch.
#
def check_batch_status(batchId)
  begin
    endpoint =  "/restapi/v1.0/account/~/a2p-sms/batches/" + batchId
    resp = $platform.get(endpoint)
    puts ("Batch status: " + resp.body['status'])
    if (resp.body['status'] != "Completed")
        sleep (5)
        check_batch_status(resp.body['id'])
    else
        puts JSON.pretty_generate(JSON.parse(resp.body.to_json))
    end
  rescue StandardError => e
    puts (e)
  end
end

# Authenticate a user using a personal JWT token
def login()
  begin
    $platform.authorize( jwt: "RC_USER_JWT" )
    read_extension_phone_number_detect_a2psms_feature()
  rescue StandardError => e
    puts ("Unable to authenticate to platform. Check credentials." + e.to_s)
  end
end

# Instantiate the SDK and get the platform instance
$platform = RingCentral.new( "RC_APP_CLIENT_ID", "RC_APP_CLIENT_SECRET", "https://platform.ringcentral.com" )

login()

# For the purpose of testing the code, we put the recipient number in the variable.
# Feel free to set the recipient number directly.
RECIPIENT = "RECIPIENT-PHONE-NUMBER"
####################################

using System;
using System.Threading.Tasks;
using RingCentral;

namespace Send_HighVolume_SMS
{
    class Program
    {
        // For the purpose of testing the code, we put the recipient number in the variable.
        // Feel free to set the recipient number directly.
        static string RECIPIENT = "RECIPIENT-PHONE-NUMBER";
        static RestClient restClient;

        static async Task Main(string[] args)
        {
          try
          {
            // Instantiate the SDK
            restClient = new RestClient( "RC_APP_CLIENT_ID", "RC_APP_CLIENT_SECRET", "https://platform.ringcentral.com");

            // Authenticate a user using a personal JWT token
            await restClient.Authorize("RC_USER_JWT");
            await read_extension_phone_number_detect_a2psms_feature();
          }
          catch (Exception ex)
          {
            Console.WriteLine(ex.Message);
          }
        }
        /*
          Read phone number(s) that belongs to this user and detect if a phone number
          has the A2P SMS capability
        */
        static private async Task read_extension_phone_number_detect_a2psms_feature()
        {
            try
            {
                var resp = await restClient.Restapi().Account().Extension().PhoneNumber().Get();
                foreach (var record in resp.records)
                {
                    foreach (var feature in record.features)
                    {
                        if (feature == "A2PSmsSender")
                        {
                            // If a user has multiple phone numbers, check and decide which number
                            // to be used for sending SMS message.
                            await send_batch_sms(record.phoneNumber);
                            return;
                        }
                    }
                }
                if (resp.records.Length == 0)
                {
                    Console.WriteLine("This user does not own a phone number!");
                }
                else
                {
                    Console.WriteLine("None of this user's phone number(s) has the A2P SMS capability!");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
        /*
         Broadcast a text message from a user own phone number to multiple recipients
        */
        static private async Task send_batch_sms(string fromNumber)
        {
            try
            {
                var bodyParams = new MessageBatchCreateRequest();
                bodyParams.from = fromNumber;
                bodyParams.messages = new MessageCreateRequest[] {
                    new MessageCreateRequest { to = new String[] { RECIPIENT } }
                    // Adding more recipients
                    /*
                    new MessageCreateRequest { to = new String[] { "Recipient2-Phone-Number } },
                    new MessageCreateRequest { to = new String[] { "RecipientN-Phone-Number } }
                    */
                };
                bodyParams.text = "Hello Team";

                var resp = await restClient.Restapi().Account().A2pSms().Batches().Post(bodyParams);
                Console.WriteLine("Batch sent. Batch id: " + resp.id);
                await check_batch_status(resp.id);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

        /*
         Send a batch from a user own phone number to multiple recipient with personalized message
        */
        static private async Task send_personalized_sms(string fromNumber)
        {
            try
            {
                var bodyParams = new MessageBatchCreateRequest();
                bodyParams.from = fromNumber;
                bodyParams.messages = new MessageCreateRequest[] {
                    new MessageCreateRequest { to = new String[] { RECIPIENT }, text = "Hello Alice" }
                    // Adding more recipients
                    /*
                    new MessageCreateRequest { to = new String[] { "Recipient2-Phone-Number }, text = "Hello Bob" },
                    new MessageCreateRequest { to = new String[] { "RecipientN-Phone-Number }, text = "Hola Maria" }
                    */
                };
                // This text becomes the default text and can be obmitted, if the text in a recipient object is not specified, this text will be used
                bodyParams.text = "Hello Team";

                var resp = await restClient.Restapi().Account().A2pSms().Batches().Post(bodyParams);
                Console.WriteLine("Batch sent. Batch id: " + resp.id);
                await check_batch_status(resp.id);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

        /*
         Check the batch status until it's completed.
         Sending a large batch will take some time for the server to complete. You can read a batch status using the batch id returned in the response after sending a batch.
        */
        static private async Task check_batch_status(string batchId)
        {
            try
            {
                var resp = await restClient.Restapi().Account().A2pSms().Batches(batchId).Get();
                Console.WriteLine("Batch status: " + resp.status);
                if (resp.status != "Completed")
                {
                    Thread.Sleep(5000);
                    await check_batch_status(resp.id);
                }
                else
                {
                    Console.WriteLine(JsonConvert.SerializeObject(resp));
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}

package Send_HighVolume_SMS;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

import com.ringcentral.*;
import com.ringcentral.definitions.*;

public class Send_HighVolume_SMS {
    // For the purpose of testing the code, we put the recipient number in the variable.
    // Feel free to set the recipient number directly.
    static String RECIPIENT = "RECIPIENT-PHONE-NUMBER";
    static RestClient restClient;

    public static void main(String[] args) {
      // Instantiate the SDK
      restClient = new RestClient( "RC_APP_CLIENT_ID", "RC_APP_CLIENT_SECRET", "https://platform.ringcentral.com");
      var obj = new Send_HighVolume_SMS();
      try {
        // Authenticate a user using a personal JWT token
        restClient.authorize( "RC_USER_JWT" );
        obj.read_extension_phone_number_detect_a2psms_feature();
      } catch (RestException | IOException e) {
        e.printStackTrace();
      }
    }
    /*
    Read phone number(s) that belongs to the authenticated user and detect if a phone number
    has the A2P SMS capability
    */
    public void read_extension_phone_number_detect_a2psms_feature() throws IOException{
      try {
        var resp =  restClient.restapi().account().extension().phoneNumber().get();
        for (var record : resp.records) {
          if (record.usageType.equalsIgnoreCase("DirectNumber")) {
            for(var feature : record.features) {
              if (feature.equalsIgnoreCase("A2PSmsSender")) {
                // If a user has multiple phone numbers, check and decide which number
                // to be used for sending SMS message.
                send_batch_sms(record.phoneNumber);
                return;
              }
            }
          }
        }
        if (resp.records.length == 0) {
          System.out.println("This user does not own a phone number!");
        } else {
          System.out.println("None of this user's phone number(s) has the A2P SMS capability!");
        }
      }catch(RestException e) {
        System.out.println(e.getMessage());
      }
    }
    /*
     Broadcast a text message from a user own phone number to multiple recipients
    */
    public void send_batch_sms(String fromNumber) throws RestException, IOException{
      try {
        var bodyParams = new MessageBatchCreateRequest();
        bodyParams.from = fromNumber;
        bodyParams.text = "Hello Team";
        bodyParams.messages = new MessageCreateRequest[] {
          new MessageCreateRequest().to ( new String[] { RECIPIENT } ),
          // Adding more recipients
          /*
          new MessageCreateRequest().to ( new String[] { "Recipient-2-Phone-Number" } ),
          new MessageCreateRequest().to ( new String[] { "Recipient-N-Phone-Number" } ),
          */
        };

        var resp = restClient.restapi().account().a2pSms().batches().post(bodyParams);
        System.out.println("Batch sent. Batch id: " + resp.id);
        check_batch_status(resp.id);
      } catch(RestException e) {
        System.out.println(e.getMessage());
      }
    }
    /*
     Send a batch from a user own phone number to multiple recipient with personalized message
    */
    public void send_personalized_sms(String fromNumber) throws RestException, IOException{
      try {
        var bodyParams = new MessageBatchCreateRequest();
        bodyParams.from = fromNumber;
        bodyParams.messages = new MessageCreateRequest[] {
          new MessageCreateRequest().to ( new String[] { RECIPIENT } ).text ("Hello Alice") ,
            // Adding more recipients
            /*
              new MessageCreateRequest().to ( new String[] { "Recipient-2-Phone-Number" } ).text ("Hello Bob"),
              new MessageCreateRequest().to ( new String[] { "Recipient-N-Phone-Number" } ).text ("Hola Maria"),
            */
        };
        // This text becomes the default text and can be obmitted, if the text in a recipient object is not specified, this text will be used
        bodyParams.text = "Hello Team";

        var resp = restClient.restapi().account().a2pSms().batches().post(bodyParams);
        System.out.println("Batch sent. Batch id: " + resp.id);
        check_batch_status(resp.id);
      } catch(RestException e) {
        System.out.println(e.getMessage());
      }
    }
    /*
     Check the batch status until it's completed.
     Sending a large batch will take some time for the server to complete. You can read a batch status using the batch id returned in the response after sending a batch.
    */
    private void check_batch_status(String batchId) throws IOException {
      try {
        var resp = restClient.restapi().account().a2pSms().batches(batchId).get();
        System.out.println("Batch status: " + resp.status);
        if (!resp.status.equals("Completed")) {
          try {
            Thread.sleep(5000);
            check_batch_status(resp.id);
          } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println(e);
          }
        }else{
          String jsonStr = new Gson().toJson(resp, new TypeToken<Object>(){}.getType());
          System.out.println(jsonStr);
        }
      } catch (RestException e) {
        System.out.println(e.getMessage());
      }
    }
}