SMS Data Redaction

    Data privacy is a key concern for every organization that processes third-party personal data, including phone numbers. With the GDPR now in effect, data privacy holds more importance today than ever.

    Plivo provides SMS redaction features to customers interested in limiting how their outbound and inbound SMS usage data is retained on Plivo’s servers and databases.

    Outbound SMS redaction

    When outbound SMS message redaction is enabled:

    • The last three digits of the destination number are redacted (replaced with ***).
    • The actual message content is redacted and replaced with ***Text Content Redacted***.
    • Redaction is applied on
      • Server logs
      • Console debug logs
      • Console debug UI
      • Customer callbacks

    Console logs UI

    outbound SMS redaction

    How to enable outbound SMS and MMS redaction

    To redact the content and destination number of an outbound SMS or MMS message, set the log request parameter of the Send SMS API request to

    false. The default value is

    true, so outbound messages are not redacted unless the log request parameter is explicitly set to

    false.

    Note: If the redaction flag is set, Plivo cannot debug or recover the message content if there are any issues.

    Code samples

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    
    import plivo
    
    client = plivo.RestClient('YOUR_AUTH_ID', 'YOUR_AUTH_TOKEN')
    
    response = client.messages.create(
          src ='14092102231', # Sender's phone number with country code
          dst ='19177220741', # Receiver's phone Number with country code
          text ='hello, test message!',
          log = False)
    print(response)
    # print str(resp)
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    
    require "plivo"
    include Plivo
    api = RestClient.new("<auth_id>", "<auth_token>")
    response = api.messages.create(
    	"+14156667778", # src
    	["+14156667777"], # dst
    	"Hello, this is a sample text", #text
    	{ 
    		url: "https://foo.com/sms_status/", 
    		log: false
    	}
    )
    puts response
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    
    // Example for Message create
    
    var plivo = require('plivo');
    
    (function main() {
        'use strict';
    
       // If auth id and auth token are not specified, Plivo will fetch them from the environment variables.
        var client = new plivo.Client("<auth_id>","<auth_token>");
        client.messages.create(
            "14092102231", // src
            "19177220741", // dst
            "hello, test message!", // text
            {log : 'false'}
        ).then(function (response) {
            console.log(response);
        }, function (err) {
            console.error(err);
        });
    })();
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    
    <?php
    require 'vendor/autoload.php';
    use Plivo\RestClient;
    use Plivo\Exceptions\PlivoRestException;
    
    $client = new RestClient("<auth_id>","<auth_token>");
    try {
        $response = $client->messages->create(
                                              '14092102231',
                                              ['19177220741'],
                                              'hello, test message!',
                                              ['log' => false]
                                              );
        print_r($response);
    }
    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.api.samples.message;
    
    import java.io.IOException;
    import java.util.Collections;
    
    import com.plivo.api.Plivo;
    import com.plivo.api.exceptions.PlivoRestException;
    import com.plivo.api.models.message.Message;
    import com.plivo.api.models.message.MessageCreateResponse;
    
    /**
     * Example for Message create
     */
    class Example {
        public static void main(String [] args) {
            Plivo.init("YOUR_AUTH_ID","YOUR_AUTH_TOKEN");
            try {
                MessageCreateResponse response = Message.creator("14092102231", Collections.singletonList("19177220741"), "hello, test message!" ).log(false)
                        .create();
    
                System.out.println(response);
            } catch (PlivoRestException | IOException 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
    
    // Example for Message create
    package main
    
    import "fmt"
    import "github.com/plivo/plivo-go"
    
    func main() {
    	client, err := plivo.NewClient("<auth_id>","<auth_token>", &plivo.ClientOptions{})
    	if err != nil {
    		panic(err)
    	}
    	response, err := client.Messages.Create(
    		plivo.MessageCreateParams{
    			Src: "14092102231",
    			Dst: "19177220741",
    			Text: "hello, test message!",
    			Log: "false",
    		},
    	)
    	if err != nil {
    		panic(err)
    	}
    	fmt.Printf("Response: %#v\n", 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
    27
    28
    29
    
    using System;
    using System.Collections.Generic;
    using Plivo;
    using Plivo.Exception;
    
    namespace Send_Sms
    {
        class Program
        {
            public static void Main(string[] args)
            {
                var api = new PlivoApi("<auth_id>","<auth_token>");
                try
                {
                    var response = api.Message.Create(
                        src: "14092102231",
                        dst: new List<String> { "19177220741" },
                        text: "hello, test message!",
                        log: false
                    );
                    Console.WriteLine(response);
                }
                catch (PlivoRestException e)
                {
                    Console.WriteLine("Exception: " + e.Message);
                }
            }
        }
    }
    
    1
    2
    3
    4
    
    curl -i --user YOUR_AUTH_ID:YOUR_AUTH_TOKEN \
        -H "Content-Type: application/json" \
        -d '{"src": "14092102231","dst": "19177220741", "text": "hello, test message!", "log": "false"}' \
        https://api.plivo.com/v1/Account/{AUTH_ID}/Message/
    

    PHLO

    outbound redaction

    Inbound SMS redaction

    When inbound SMS message redaction is enabled:

    • The last three digits of the originating number are redacted (replaced with ***).
    • The actual message content is redacted and replaced with ***Text Content Redacted***.
    • Redaction is applied on
      • Server logs
      • Console debug logs
      • Console debug UI

    Console logs UI

    Inbound redaction

    Inbound MMS redaction

    When inbound message redaction is enabled:

    • The source number is redacted in logs and in the Message Detail Record (MDR).
    • Hyperlinks for attached media are logged anywhere on Plivo server logs, including callback logs.
    • Media subresources for the received media are created and will remain accessible. They may be deleted by explicitly invoking the Delete Media API to delete the media files hosted on Plivo servers.

    How to enable inbound SMS and MMS redaction

    You can control inbound SMS and MMS redaction at the application level.

    Setting the application-level flag log_incoming_messages to

    false enables redaction. The default value is

    true, so inbound messages are not redacted unless the flag is explicitly set to

    false. The text and from_number fields are redacted when redaction is enabled.

    When message redaction is enabled for an application, incoming messages to Plivo phone numbers associated with the application are redacted.

    Note: If inbound messages are redacted, Plivo cannot debug or recover message content if there are any issues with the callback URL.

    Code samples

    1
    2
    3
    4
    5
    6
    7
    
    import plivo
    
    client = plivo.RestClient('<auth_id>','<auth_token>')
    response = client.applications.create(
        app_name='Test Application',
        answer_url='https://answer.url', log_incoming_messages= False)
    print(response)
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    
    #
    # Example for Application Create
    #
    require 'rubygems'
    require 'plivo'
    
    include Plivo
    include Plivo::Exceptions
    
    api = RestClient.new("<auth_id>","<auth_token>")
    
    begin
        response = api.applications.create(
           'Test Application',
           answer_url: 'https://answer.url',
           answer_method: 'GET',
           log_incoming_messages: false
           )
           puts response
    rescue PlivoRESTError => e
    puts 'Exception: ' + e.message
    end
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    
    // Example for Application create
    
    var plivo = require('plivo');
    
    (function main() {
        'use strict';
    
       // If auth id and auth token are not specified, Plivo will fetch them from the environment variables.
        var client = new plivo.Client("<auth_id>","<auth_token>");
        client.applications.create(
            "Test Application", // app name
        	{
    		answerUrl: "https://answer.url", // answer url
            logIncomingMessages: "false"
    	}
        ).then(function (response) {
            console.log(response);
        }, function (err) {
            console.error(err);
        });
    })();
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    
    <?php
    /**
     * Example for Application create
     */
    require 'vendor/autoload.php';
    use Plivo\RestClient;
    use Plivo\Exceptions\PlivoRestException;
    $client = new RestClient("<auth_id>","<auth_token>");
    
    try {
        $response = $client->applications->create(
    	    'Test Application',
    	    [
    		'answer_url' => 'https://answer.url',
    	    'answer_method' => 'POST',
    	    'log_incoming_messages' => 'false'
    		]
    	    );
        print_r($response);
    }
    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
    
    package com.plivo.api.samples.application;
    
    import java.io.IOException;
    import com.plivo.api.Plivo;
    import com.plivo.api.exceptions.PlivoRestException;
    import com.plivo.api.models.application.Application;
    import com.plivo.api.models.application.ApplicationCreateResponse;
    /**
     * Example for Message create
     */
    class Example {
        public static void main(String [] args) {
            Plivo.init("YOUR_AUTH_ID","YOUR_AUTH_TOKEN");
            try {
                ApplicationCreateResponse response = Application.creator("Test Application").answerUrl("https://answer.url").logIncomingMessages(false)
                        .create();
                System.out.println(response);
            } catch (PlivoRestException | IOException 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
    
    // Example for Application create
    package main
    
    import (
    	"fmt"
    
    	"github.com/plivo/plivo-go"
    )
    
    func main() {
    	client, err := plivo.NewClient("<auth_id>", "<auth_token>", &plivo.ClientOptions{})
    	if err != nil {
    		panic(err)
    	}
    	response, err := client.Applications.Create(
    		plivo.ApplicationCreateParams{
    			AppName:             "Test Application",
    			AnswerURL:           "https://answer.url",
    			LogIncomingMessages: false,
    		},
    	)
    	if err != nil {
    		panic(err)
    	}
    	fmt.Printf("Response: %#v\n", 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
    27
    28
    
    using System;
    using System.Collections.Generic;
    using Plivo;
    using Plivo.Exception;
    
    namespace apps
    {
        class Program
        {
            public static void Main(string[] args)
            {
                var api = new PlivoApi("<auth_id>","<auth_token>");
                try
                {
                    var response = api.Application.Create(
                        appName: "Test Application",
                        answerUrl: "https://answer.url",
                        logIncomingMessages: false
                    );
                    Console.WriteLine(response);
                }
                catch (PlivoRestException e)
                {
                    Console.WriteLine("Exception: " + e.Message);
                }
            }
        }
    }
    
    1
    2
    3
    4
    
    curl -i --user YOUR_AUTH_ID:YOUR_AUTH_TOKEN \
        -H "Content-Type: application/json" \
        -d '{"answer_url": "https://example.com", "app_name": "Test Application", "log_incoming_messages": "false"}' \
        https://api.plivo.com/v1/Account/{AUTH_ID}/Application/
    

    Console UI

    Inbound SMS redaction

    PHLO

    Inbound redaction