Register a Standard brand

    This API lets you register a standard brand using a preexisting profile.

    addressPostal address indicated during brand creation.
    authorized_contactAuthorized contact information indicated during brand creation.
    brand_idUnique identifier for the brand created.
    brand_typeType of registration indicated during brand creation.
    company_nameLegal name of the company
    einEmployer Identification Number associated with a Standard brand.
    ein_issuing_countryISO alpha-2 code for the country that issued the EIN.
    entity_typeType of ownership indicated during brand creation.
    profile_uuidUnique identifier for the profile used to create brand.
    registration_statusIndicates status of brand.
    verticalCompany industry.
    vetting_scoreVetting score assigned to brand by TCR. Not applicable for Starter brands.
    vetting_statusVetting status of a brand. Not applicable for Starter brands.
    POST https://api.plivo.com/v1/Account/{auth_id}/10dlc/Brand/

    Arguments

    profile_uuidstringrequiredUnique identifier for the profile that you want to use for creating a brand. The profile should not have been used to create another brand.
    brand_aliasstringrequiredA friendly name for the brand.
    brand_typestring

    Indicate type of registration.

    Allowed values: STANDARD, STARTER. STANDARD not allowed for profiles not containing an EIN.

    Defaults to STARTER.

    secondary_vettingboolean

    Allowed values: true, false. Only applicable for STANDARD registration.

    Defaults to true.

    Plivo strongly recommends opting for vetting to get the highest throughput for your brands and campaigns.

    urlstringThe fully qualified URL to which status update callbacks for the message should be sent.
    methodstring

    The HTTP method to be used when calling the URL defined above.

    Allowed values: GET, POST

    Defaults to POST

    Returns

    api_id for the request, unique brand_id, and success message

    Response

    HTTP Status Code: 200

    {
       "api_id": "43751b36-bbc4-11ec-9f72-0242ac110002",
       "brand_id": "BCDEF1G",
       "message": "Request to create brand was received and is being processed."
    }
    

    Example Request

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    
    import plivo
    
    client = plivo.RestClient("<auth_id>", "<auth_token>")
    response = client.brand.create(
        brand_alias="brand name sample",
        brand_type="STANDARD",
        profile_uuid="<ProfileUUID>",
        secondary_vetting=False,
        url="https://example.come/test",
        method="POST",
    )
    print(response)
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    
    require "rubygems"
    require "/etc/plivo-ruby/lib/plivo.rb"
    include Plivo
    
    api = RestClient.new("<auth_id>", "<auth_token>")
    
    begin
    response = api.brand.create(    brand_alias: "<brand name>",
                                    profile_uuid: "<profile_uuid>",
                                    secondary_vetting: true,
                                    brand_type: "STANDARD",
                                    url:"<https://<yourdomain>.com/create_brand_status/>",
                                    method: "POST"
                                )
    
    puts response
    rescue PlivoRESTError => e
        puts 'Exception: ' + e.message
    end
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    
    let plivo = require('plivo');
    
    let client = new plivo.Client("<auth_id>", "<auth_token>");
    var callback = {"url":"https://<yourdomain>.com/tendlc_status/", "method":"POST"}
    
    client.brand.create("govt", "<profile_uuid>", "STANDARD", true, callback)
        .then(function (response) {
            console.log(JSON.stringify(response));
        }).catch(function (error) {
            console.log("err");
            console.log(error);
        });
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    
    <?php
    
    # Available in versions >= 4.29.0 (https://github.com/plivo/plivo-php/releases/tag/v4.29.0)
    
    require '/etc/plivo-php/vendor/autoload.php';
    use Plivo\RestClient;
    $client = new RestClient("<auth_id>", "<auth_token>");
    $client
        ->client
        ->setTimeout(60);
    try
    {
        $callback = array("url"=>"https://<yourdomain>.com/tendlc_status/", "method"=>"POST");
        $res = $client
            ->brand
            ->create("govt321", "<profile_uuid>", "STANDARD", true, $callback);
        print_r($res);
    }
    catch(PlivoRestException $ex)
    {
        print_r($ex);
    }
    ?>
    
    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
    
    package com.plivo.examples;
    
    import com.plivo.api.Plivo;
    import com.plivo.api.models.brand.Brand;
    import com.plivo.api.models.brand.BrandCreateResponse;
    
    public class PlivoTest {
    
        public static void main(String[] args) {
    
            Plivo.init("<auth_id>", "<auth_token>");
    
            // Create Brand
            try {
                BrandCreateResponse response = Brand.creator("brand name",
                    "<profile_uuid>",
                    "STANDARD",
                    true,
                    "<https://<yourdomain>.com/create_brand_status/>",
                    "POST").create();
                System.out.println(response);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    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
    
    using System;
    using System.Collections.Generic;
    using Plivo;
    using Plivo.Exception;
    
    namespace dotnet_project
    {
        class Ten_dlc
        {
            static void Main(string[] args)
            {
    
                    var api = new PlivoApi("<auth_id>","<auth_token>");
    
                    // Create Brand
                try
                {
                    var response = api.Brand.Create("brand_001", "201faedc-7df9-4840-9ab1-3997ce3f7cf4", "STANDARD", true, "https://<yourdomain>.com/tendlc_status/", "POST");
                    Console.WriteLine(response);
                }
                catch (PlivoRestException e)
                {
                        Console.WriteLine("Exception: " + e.Message);
                }
    
    
            }
        }
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    
    curl -i --user auth_id:auth_token \
        -H "Content-Type: application/json" \
        -d '{
                "brand_alias": "gov234t",
                "profile_uuid": "d61eaaaa-18b1-4473-8810-0b9d80573aa9",
                "brand_type": "STANDARD",
                "secondary_vetting": true,
                "url": "https://<yourdomain>.com/tendlc_status/",
                "method": "POST"
            }' \
            https://api.plivo.com/v1/Account/{auth_id}/10dlc/Brand/
    
    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
    
    package main
    
    import (
    	"fmt"
    	"os"
    
    	plivo "github.com/plivo/plivo-go/"
    )
    
    func main() {
    	client, err := plivo.NewClient("<auth_id>", "<auth_token>", &plivo.ClientOptions{})
    	if err != nil {
    		panic(err)
    	}
    	//Create Brand
    	response, err := client.Brand.Create(plivo.BrandCreationParams{
    		BrandAlias:  "<brand name>",
    		Type:        "STANDARD",
    		ProfileUUID: "<profile_uuid>",
    		URL:         "https://example.come/test",
    		Method:      "POST",
    	})
    	if err != nil {
    		fmt.Printf("Error occurred while creating brand. error:%+v\n", err)
    		os.Exit(1)
    	} else {
    		fmt.Printf("%+v\n", response)
    	}
    }