Menu

Get Sent Campaigns Summary

GET https://examplebaseURL.com/v1/api/apps/{appID}/data/sent-campaigns-summary

Response Format

Copy 
  <th style={{ textAlign: "left" }}>
    Type
  </th>

  <th style={{ textAlign: "left" }}>
    Description
  </th>

  <th style={{ textAlign: "left" }}>
    Availability
  </th>
</tr>
Copy 
  <td style={{ textAlign: "left" }}>
    String
  </td>

  <td style={{ textAlign: "left" }}>
    * The unique ID of the created campaign.  
    * This ID serves as the historyID of the particular campaign when you use the open API to get the sent campaign details. - Please refer to [Get Sent Campaigns Details](https://docs.cinnox.com/reference/get-sent-campaigns-details) for more details.
  </td>

  <td style={{ textAlign: "left" }}>
    In the WhatsApp and SMS Campaigns
  </td>
</tr>

<tr>
  <td style={{ textAlign: "left" }}>
    date
  </td>

  <td style={{ textAlign: "left" }}>
    String
  </td>

  <td style={{ textAlign: "left" }}>
    The date and time the campaign was sent. The value must be in RFC3339 format, e.g. 2022-11-07T00:00:00.000Z.
  </td>

  <td style={{ textAlign: "left" }}>
    In the WhatsApp and SMS Campaigns
  </td>
</tr>

<tr>
  <td style={{ textAlign: "left" }}>
    campaignName
  </td>

  <td style={{ textAlign: "left" }}>
    String
  </td>

  <td style={{ textAlign: "left" }}>
    The campaign name of the sent campaign.
  </td>

  <td style={{ textAlign: "left" }}>
    In the WhatsApp and SMS Campaigns
  </td>
</tr>

<tr>
  <td style={{ textAlign: "left" }}>
    channel
  </td>

  <td style={{ textAlign: "left" }}>
    String
  </td>

  <td style={{ textAlign: "left" }}>
    The channel used to send the campaign. The channel can be SMS or WhatsApp. 
  </td>

  <td style={{ textAlign: "left" }}>
    In the WhatsApp and SMS Campaigns
  </td>
</tr>

<tr>
  <td style={{ textAlign: "left" }}>
    createdBy
  </td>

  <td style={{ textAlign: "left" }}>
    String
  </td>

  <td style={{ textAlign: "left" }}>
    The staff name who created the sent campaign. 
  </td>

  <td style={{ textAlign: "left" }}>
    In the WhatsApp and SMS Campaigns
  </td>
</tr>

<tr>
  <td style={{ textAlign: "left" }}>
    sender.phone
  </td>

  <td style={{ textAlign: "left" }}>
    String
  </td>

  <td style={{ textAlign: "left" }}>
    * The phone number used to send the campaign.  
    * For the SMS campaign, this phone number can be the virtual number, service number or alphanumeric Sender ID.  
    * For the WhatsApp campaign, this phone number is bound to the WhatsApp Channel 
  </td>

  <td style={{ textAlign: "left" }}>
    In the WhatsApp and SMS Campaigns
  </td>
</tr>

<tr>
  <td style={{ textAlign: "left" }}>
    sender.channelName
  </td>

  <td style={{ textAlign: "left" }}>
    String
  </td>

  <td style={{ textAlign: "left" }}>
    The channel name used to send the campaign. 
  </td>

  <td style={{ textAlign: "left" }}>
    In the WhatsApp Campaign
  </td>
</tr>

<tr>
  <td style={{ textAlign: "left" }}>
    sender.sourceName
  </td>

  <td style={{ textAlign: "left" }}>
    String
  </td>

  <td style={{ textAlign: "left" }}>
    The source of the template used in the sent campaign. 
  </td>

  <td style={{ textAlign: "left" }}>
    In the WhatsApp Campaign
  </td>
</tr>

<tr>
  <td style={{ textAlign: "left" }}>
    sender.senderEID
  </td>

  <td style={{ textAlign: "left" }}>
    String
  </td>

  <td style={{ textAlign: "left" }}>
    The staff unique ID who sent the campaign. 
  </td>

  <td style={{ textAlign: "left" }}>
    In the SMS Campaign
  </td>
</tr>

<tr>
  <td style={{ textAlign: "left" }}>
    subject
  </td>

  <td style={{ textAlign: "left" }}>
    String
  </td>

  <td style={{ textAlign: "left" }}>
    The name of the template used for the campaign.
  </td>

  <td style={{ textAlign: "left" }}>
    In the WhatsApp Campaign
  </td>
</tr>

<tr>
  <td style={{ textAlign: "left" }}>
    totalRecipients
  </td>

  <td style={{ textAlign: "left" }}>
    Number
  </td>

  <td style={{ textAlign: "left" }}>
    The total phone number of campaign recipients of the WhatsApp or SMS Campaign.
  </td>

  <td style={{ textAlign: "left" }}>
    In the WhatsApp and SMS Campaigns
  </td>
</tr>

<tr>
  <td style={{ textAlign: "left" }}>
    delivered
  </td>

  <td style={{ textAlign: "left" }}>
    Number
  </td>

  <td style={{ textAlign: "left" }}>
    The total number of campaign messages successfully sent to recipients.
  </td>

  <td style={{ textAlign: "left" }}>
    In the WhatsApp and SMS Campaigns
  </td>
</tr>

<tr>
  <td style={{ textAlign: "left" }}>
    read
  </td>

  <td style={{ textAlign: "left" }}>
    Number
  </td>

  <td style={{ textAlign: "left" }}>
    The total number of campaign messages read by recipients.
  </td>

  <td style={{ textAlign: "left" }}>
    In the WhatsApp Campaign
  </td>
</tr>

<tr>
  <td style={{ textAlign: "left" }}>
    replied
  </td>

  <td style={{ textAlign: "left" }}>
    Number
  </td>

  <td style={{ textAlign: "left" }}>
    Represents the total number of replies generated through clicks on buttons or web links included in the WhatsApp campaign message.  

    The 'replied status' counts replies to the campaign message based on the following criteria:  

    * Replies via buttons: If a recipient clicks on a button multiple times, the replies are only counted once.  
    * Replies via web links: If a recipient clicks on a web link, each click is counted as a separate reply, even if the same recipient makes multiple clicks.
  </td>

  <td style={{ textAlign: "left" }}>
    In the WhatsApp Campaign
  </td>
</tr>

<tr>
  <td style={{ textAlign: "left" }}>
    pending
  </td>

  <td style={{ textAlign: "left" }}>
    Number
  </td>

  <td style={{ textAlign: "left" }}>
    The campaign message was successfully sent from CINNOX, but it is still waiting for a "Delivered" response from the 360dialog to the recipients.
  </td>

  <td style={{ textAlign: "left" }}>
    In the WhatsApp Campaign
  </td>
</tr>

<tr>
  <td style={{ textAlign: "left" }}>
    failed
  </td>

  <td style={{ textAlign: "left" }}>
    Number
  </td>

  <td style={{ textAlign: "left" }}>
    The total number of campaign messages that failed to send to recipients.
  </td>

  <td style={{ textAlign: "left" }}>
    In the WhatsApp Campaign
  </td>
</tr>
Parameter
id

📘 For more details on the Sent Campaign, please refer to the Get Sent Campaigns Details section of our User Guides.

Path Params

appID string required
App ID

Query Params

startAt string
The start date and time for the period of the sent campaign. The value must be in RFC3339 format, e.g. 2022-11-07T00:00:00.000Z.

endAt string
The end date and time for the period of the sent campaign. The value must be in RFC3339 format, e.g. 2022-11-08T00:00:00.000Z.

channel string
The channel used for the sent campaign. The value must be either "sms" or "whatsApp". An empty value will be provided.

limit int32 Defaults to 10
The number of data that will be returned, e.g. if the set limit is 10, 10 records returned in the response. The default value is 10, and the maximum value is 200.

offset int32 Defaults to 0
Skip the number of the shown data in the response. If the offset value is 10, the first 10 data will be skipped. The default value is 0.

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 GET \
     --url 'https://examplebaseurl.com/v1/api/apps/appID/data/sent-campaigns-summary?limit=10&offset=0' \
     --header 'Authorization: Bearer AppToken' \
     --header 'Content-Type: application/json' \
     --header 'accept: application/json'
Shell: HTTPie Request Copy 
$ brew install httpie
http GET 'https://examplebaseurl.com/v1/api/apps/appID/data/sent-campaigns-summary?limit=10&offset=0' \
  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: 'GET',
  url: 'https://examplebaseurl.com/v1/api/apps/appID/data/sent-campaigns-summary?limit=10&offset=0',
  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/data/sent-campaigns-summary?limit=10&offset=0';
const options = {
  method: 'GET',
  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: 'GET',
  hostname: 'examplebaseurl.com',
  port: null,
  path: '/v1/api/apps/appID/data/sent-campaigns-summary?limit=10&offset=0',
  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.getSentCampaignsSummary({limit: '10', offset: '0', 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/data/sent-campaigns-summary?limit=10&offset=0")

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

request = Net::HTTP::Get.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/data/sent-campaigns-summary?limit=10&offset=0",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  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('GET', 'https://examplebaseurl.com/v1/api/apps/appID/data/sent-campaigns-summary?limit=10&offset=0', [
  '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/data/sent-campaigns-summary?limit=10&offset=0"

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

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

print(response.text)

LANGUAGE: C

Request Copy 
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_WRITEDATA, stdout);
curl_easy_setopt(hnd, CURLOPT_URL, "https://examplebaseurl.com/v1/api/apps/appID/data/sent-campaigns-summary?limit=10&offset=0");

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.Get,
    RequestUri = new Uri("https://examplebaseurl.com/v1/api/apps/appID/data/sent-campaigns-summary?limit=10&offset=0"),
    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/data/sent-campaigns-summary?limit=10&offset=0");
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.GetAsync(request);

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

LANGUAGE: C++

Request Copy 
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_WRITEDATA, stdout);
curl_easy_setopt(hnd, CURLOPT_URL, "https://examplebaseurl.com/v1/api/apps/appID/data/sent-campaigns-summary?limit=10&offset=0");

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/get "https://examplebaseurl.com/v1/api/apps/appID/data/sent-campaigns-summary" {:headers {:Content-Type "application/json"
                                                                                                  :Authorization "Bearer AppToken"}
                                                                                        :query-params {:limit "10"
                                                                                                       :offset "0"}
                                                                                        :accept :json})

LANGUAGE: Go

Request Copy 
package main

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

func main() {

	url := "https://examplebaseurl.com/v1/api/apps/appID/data/sent-campaigns-summary?limit=10&offset=0"

	req, _ := http.NewRequest("GET", 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 
GET /v1/api/apps/appID/data/sent-campaigns-summary?limit=10&offset=0 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("GET", "https://examplebaseurl.com/v1/api/apps/appID/data/sent-campaigns-summary?limit=10&offset=0")
  .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/data/sent-campaigns-summary?limit=10&offset=0"))
    .header("accept", "application/json")
    .header("Content-Type", "application/json")
    .header("Authorization", "Bearer AppToken")
    .method("GET", 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/data/sent-campaigns-summary?limit=10&offset=0")
  .get()
  .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.get("https://examplebaseurl.com/v1/api/apps/appID/data/sent-campaigns-summary?limit=10&offset=0")
  .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: 'GET',
  url: 'https://examplebaseurl.com/v1/api/apps/appID/data/sent-campaigns-summary',
  params: {limit: '10', offset: '0'},
  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: 'GET',
  headers: {
    accept: 'application/json',
    'Content-Type': 'application/json',
    Authorization: 'Bearer AppToken'
  }
};

fetch('https://examplebaseurl.com/v1/api/apps/appID/data/sent-campaigns-summary?limit=10&offset=0', 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/data/sent-campaigns-summary?limit=10&offset=0',
  method: 'GET',
  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('GET', 'https://examplebaseurl.com/v1/api/apps/appID/data/sent-campaigns-summary?limit=10&offset=0');
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/data/sent-campaigns-summary?limit=10&offset=0")
  .get()
  .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/data/sent-campaigns-summary?limit=10&offset=0"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[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/data/sent-campaigns-summary?limit=10&offset=0" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "application/json");
  ("Content-Type", "application/json");
  ("Authorization", "Bearer AppToken");
] in

Client.call ~headers `GET 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/data/sent-campaigns-summary?limit=10&offset=0' -Method GET -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/data/sent-campaigns-summary?limit=10&offset=0' -Method GET -Headers $headers

LANGUAGE: R

Request Copy 
library(httr)

url <- "https://examplebaseurl.com/v1/api/apps/appID/data/sent-campaigns-summary"

queryString <- list(
  limit = "10",
  offset = "0"
)

response <- VERB("GET", url, query = queryString, 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/data/sent-campaigns-summary")!
var components = URLComponents(url: url, resolvingAgainstBaseURL: true)!
let queryItems: [URLQueryItem] = [
  URLQueryItem(name: "limit", value: "10"),
  URLQueryItem(name: "offset", value: "0"),
]
components.queryItems = components.queryItems.map { $0 + queryItems } ?? queryItems

var request = URLRequest(url: components.url!)
request.httpMethod = "GET"
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

RESPONSE: 200-Result

200-Result Copy 
{
    "code": number,
    "result": [     
       {
            "id": "string",
            "date": "string",
            "campaignName": "string",
            "channel": "string",
            "createdBy": "string",
            "sender": {
                "phone": "string",
                "channelName": "string",
                "sourceName": "string",
                "senderEID": "string"
            },
            "subject": "string",
            "totalRecipients": "number",
            "delivered": "number",
            "read": "number",
            "replied": "number",
            "pending": "number",
            "failed": "number"
        }     
    ],
    "cid": "string"
}

RESPONSE: 400-Result

400-Result Copy 
{
  "code": 0,
  "message": "The error message from the server. Please refer to the error table."
}
Last modified: 2025-12-11