Menu

Create/Edit/Delete Outbound SMS Event Subscription

PATCH https://examplebaseURL.com/v1/api/apps/{appID}/outbound-sms-event-sub

Response Format

Parameter Type Description
enabled boolean It must be true or false. True indicates the subscription is successful, while false indicates it is unsuccessful.
url String The webhook URL. In access to this URL, you can receive the notification of the outbound SMS message when sent from Cinnox. For details, please refer to the Notification of the New Outbound SMS Message.
updatedAt String The updated date and time of this subscription. The value must be in RFC3339 format, e.g. 2022-11-07T00:00:00.000Z.

Notification of Outbound SMS Message

You can receive the notification of the new outbound SMS message by accessing the webhook URL after subscribing to the event of the Outbound SMS message.

Notification Details Type Description
Type String In this case, the result must be "tdr" (Transaction Detail Record).
AppID String Your AppID is using this open API endpoint.
ServiceID String Your CINNOX service ID.
TransactionID String The SMS ID of this outbound SMS message.
RecipientNumber Number The SMS number of the recipient. The format is "Country code + phone number". Example: 85298765432.
RecipientCountry String The location of the SMS recipient. The result is shown in the following format: (Country represented by Two-letter country code based on ISO 3166-2) Example: VE =Venezuela.
ResponseCode String It must be either blank when the status is either "Submitted" or "Delivered" or 400 when the status is either "Undelivered" or "Rejected".
Status String It shows the status of the outbound SMS message. It can be one of the following statuses: * Submitted: The SMS has been submitted to the Carrier. * Delivered: The Carrier has successfully delivered the SMS to the recipient. * Undelivered: The Carrier did not successfully deliver the SMS to the recipient. * Rejected: The Carrier has rejected the SMS.
Exception String It shows whether or not it is an error SMS message. If it is blank, the SMS message has no error, while it shows either "sms send failed" or "sms deliver failed" if it is an error message.

🚧 Webhook URL Requirement:

The webhook URL needs to be verified. After that, you will get a POST request with an Action and are required to set the response in JSON Response Format as shown below:

Note that the JsonResponse result is JSON encoding of the Action Endpoint Response.

Action Endpoint Request {
+ Challenge string json: "challenge"
+ }

Action Endpoint Response {
+ Challenge string json: "challenge"
+ }

Json Response {
+ Code int json: "code"
+ Result json.RawMessage json: "result"
+ }

Path Params

appID string required
App ID

Body Params

enabled (Required) boolean
To subscribe to the event of the outbound SMS message, please input "true" as the value. To unsubscribe from an existing event, please input "false" as the value.

url (Required) string
This is the webhook URL. You will get a POST request with an Action and must set the response in JSON Response format.

Headers

Content-Type string
application/json

Authorization string
Bearer AppToken

Responses

200
Response body
json

400
Response body
object
code integer Defaults to 0
message string

Language

LANGUAGE: Shell

Shell: cURL Request Copy 
curl --request PATCH \
     --url https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub \
     --header 'Authorization: Bearer AppToken' \
     --header 'Content-Type: application/json' \
     --header 'accept: application/json'
Shell: HTTPie Request Copy 
$ brew install httpie
http PATCH https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub \
  Authorization:'Bearer AppToken' \
  Content-Type:application/json \
  accept:application/json

LANGUAGE: Node

Node: Axios Request Copy 
$ npm install axios --save
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: 'https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub',
  headers: {
    accept: 'application/json',
    'Content-Type': 'application/json',
    Authorization: 'Bearer AppToken'
  }
};

axios
  .request(options)
  .then(res => console.log(res.data))
  .catch(err => console.error(err));
Node: fetch Request Copy 
const url = 'https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub';
const options = {
  method: 'PATCH',
  headers: {
    accept: 'application/json',
    'Content-Type': 'application/json',
    Authorization: 'Bearer AppToken'
  }
};

fetch(url, options)
  .then(res => res.json())
  .then(json => console.log(json))
  .catch(err => console.error(err));
Node: http Request Copy 
const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'examplebaseurl.com',
  port: null,
  path: '/v1/api/apps/appID/outbound-sms-event-sub',
  headers: {
    accept: 'application/json',
    'Content-Type': 'application/json',
    Authorization: 'Bearer AppToken'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

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

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
Node: API Request Copy 
$ npx api install "@cinnox2021/v7.3#45i1wk2km9l1e4hf"
import cinnox2021 from '@api/cinnox2021';

cinnox2021.createeditdeleteOutboundsmsEventSubscription({appID: 'appID', Authorization: 'Bearer AppToken'})
  .then(({ data }) => console.log(data))
  .catch(err => console.error(err));

LANGUAGE: Ruby

Request Copy 
require 'uri'
require 'net/http'

url = URI("https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub")

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

request = Net::HTTP::Patch.new(url)
request["accept"] = 'application/json'
request["Content-Type"] = 'application/json'
request["Authorization"] = 'Bearer AppToken'

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

LANGUAGE: PHP

PHP: cURL Request Copy 
<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer AppToken",
    "Content-Type: application/json",
    "accept: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
PHP: Guzzle Request Copy 
$ composer require guzzlehttp/guzzle
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PATCH', 'https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub', [
  'headers' => [
    'Authorization' => 'Bearer AppToken',
    'Content-Type' => 'application/json',
    'accept' => 'application/json',
  ],
]);

echo $response->getBody();

LANGUAGE: Python

Request Copy 
$ python -m pip install requests
import requests

url = "https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub"

headers = {
    "accept": "application/json",
    "Content-Type": "application/json",
    "Authorization": "Bearer AppToken"
}

response = requests.patch(url, headers=headers)

print(response.text)

LANGUAGE: C

Request Copy 
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_WRITEDATA, stdout);
curl_easy_setopt(hnd, CURLOPT_URL, "https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: application/json");
headers = curl_slist_append(headers, "Content-Type: application/json");
headers = curl_slist_append(headers, "Authorization: Bearer AppToken");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

LANGUAGE: C#

C#: HttpClient Request Copy 
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub"),
    Headers =
    {
        { "accept", "application/json" },
        { "Authorization", "Bearer AppToken" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
C#: RestSharp Request Copy 
$ dotnet add package RestSharp
using RestSharp;


var options = new RestClientOptions("https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub");
var client = new RestClient(options);
var request = new RestRequest("");
request.AddHeader("accept", "application/json");
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Authorization", "Bearer AppToken");
var response = await client.PatchAsync(request);

Console.WriteLine("{0}", response.Content);

LANGUAGE: C++

Request Copy 
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_WRITEDATA, stdout);
curl_easy_setopt(hnd, CURLOPT_URL, "https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: application/json");
headers = curl_slist_append(headers, "Content-Type: application/json");
headers = curl_slist_append(headers, "Authorization: Bearer AppToken");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

LANGUAGE: Clojure

Request Copy 
(require '[clj-http.client :as client])

(client/patch "https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub" {:headers {:Content-Type "application/json"
                                                                                               :Authorization "Bearer AppToken"}
                                                                                     :accept :json})

LANGUAGE: Go

Request Copy 
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub"

	req, _ := http.NewRequest("PATCH", url, nil)

	req.Header.Add("accept", "application/json")
	req.Header.Add("Content-Type", "application/json")
	req.Header.Add("Authorization", "Bearer AppToken")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

LANGUAGE: HTTP

Request Copy 
PATCH /v1/api/apps/appID/outbound-sms-event-sub HTTP/1.1
Accept: application/json
Content-Type: application/json
Authorization: Bearer AppToken
Host: examplebaseurl.com

LANGUAGE: Java

Java: AsyncHttp Request Copy 
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub")
  .setHeader("accept", "application/json")
  .setHeader("Content-Type", "application/json")
  .setHeader("Authorization", "Bearer AppToken")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
Java: java.net.http. Request Copy 
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub"))
    .header("accept", "application/json")
    .header("Content-Type", "application/json")
    .header("Authorization", "Bearer AppToken")
    .method("PATCH", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
Java: OkHttp. Request Copy 
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub")
  .patch(null)
  .addHeader("accept", "application/json")
  .addHeader("Content-Type", "application/json")
  .addHeader("Authorization", "Bearer AppToken")
  .build();

Response response = client.newCall(request).execute();
Java: Unirest Request Copy 
HttpResponse<String> response = Unirest.patch("https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub")
  .header("accept", "application/json")
  .header("Content-Type", "application/json")
  .header("Authorization", "Bearer AppToken")
  .asString();

LANGUAGE: JavaScript

JavaScript: Axios Request Copy 
$ npm install axios --save
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: 'https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub',
  headers: {
    accept: 'application/json',
    'Content-Type': 'application/json',
    Authorization: 'Bearer AppToken'
  }
};

axios
  .request(options)
  .then(res => console.log(res.data))
  .catch(err => console.error(err));
JavaScript: fetch Request Copy 
const options = {
  method: 'PATCH',
  headers: {
    accept: 'application/json',
    'Content-Type': 'application/json',
    Authorization: 'Bearer AppToken'
  }
};

fetch('https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));
JavaScript: jQuery Request Copy 
const settings = {
  async: true,
  crossDomain: true,
  url: 'https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub',
  method: 'PATCH',
  headers: {
    accept: 'application/json',
    'Content-Type': 'application/json',
    Authorization: 'Bearer AppToken'
  }
};

$.ajax(settings).done(res => {
  console.log(res);
});
JavaScript: XMLHttpRequest Request Copy 
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', 'https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub');
xhr.setRequestHeader('accept', 'application/json');
xhr.setRequestHeader('Content-Type', 'application/json');
xhr.setRequestHeader('Authorization', 'Bearer AppToken');

xhr.send(data);

LANGUAGE: JSON

Request Copy 
No JSON body

LANGUAGE: Kotlin

Request Copy 
val client = OkHttpClient()

val request = Request.Builder()
  .url("https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub")
  .patch(null)
  .addHeader("accept", "application/json")
  .addHeader("Content-Type", "application/json")
  .addHeader("Authorization", "Bearer AppToken")
  .build()

val response = client.newCall(request).execute()

LANGUAGE: Objectve-C

Request Copy 
#import <Foundation/Foundation.h>

NSDictionary *headers = @{ @"accept": @"application/json",
                           @"Content-Type": @"application/json",
                           @"Authorization": @"Bearer AppToken" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

LANGUAGE: OCaml

Request Copy 
$ opam install cohttp-lwt-unix cohttp-async
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "application/json");
  ("Content-Type", "application/json");
  ("Authorization", "Bearer AppToken");
] in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

LANGUAGE: PowerShell

PowerShell: Invoke-RestMethod Request Copy 
$headers=@{}
$headers.Add("accept", "application/json")
$headers.Add("Content-Type", "application/json")
$headers.Add("Authorization", "Bearer AppToken")
$response = Invoke-RestMethod -Uri 'https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub' -Method PATCH -Headers $headers
PowerShell: Invoke-WebRequest Request Copy 
$headers=@{}
$headers.Add("accept", "application/json")
$headers.Add("Content-Type", "application/json")
$headers.Add("Authorization", "Bearer AppToken")
$response = Invoke-WebRequest -Uri 'https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub' -Method PATCH -Headers $headers

LANGUAGE: R

Request Copy 
library(httr)

url <- "https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub"

response <- VERB("PATCH", url, add_headers('Authorization' = 'Bearer AppToken'), content_type("application/octet-stream"), accept("application/json"))

content(response, "text")

LANGUAGE: Swift

Request Copy 
import Foundation

let url = URL(string: "https://examplebaseurl.com/v1/api/apps/appID/outbound-sms-event-sub")!
var request = URLRequest(url: url)
request.httpMethod = "PATCH"
request.timeoutInterval = 10
request.allHTTPHeaderFields = [
  "accept": "application/json",
  "Content-Type": "application/json",
  "Authorization": "Bearer AppToken"
]

let (data, _) = try await URLSession.shared.data(for: request)
print(String(decoding: data, as: UTF8.self))

Response Example

RESPONSE: 200-Result

200-Result Copy 
{
  "code": number,
  "result": {
    "enabled": boolean,
    "url": "string",
    "updatedAt": "string"
  }
}

RESPONSE: 400-Result

400-Result Copy 
{
  "code": 0,
  "message": "The error message from the server. Please refer to the error table."
}
Previous
Create/Edit/Delete Inbound SMS Event Subscription
Next
Management API
Last modified: 2025-12-12