Get Enquiry Overview Matrix

GET https://examplebaseURL.com/v1/api/apps/{appID}/enquiry/overview_matrix?{startAt=}&{endAt=}

Response Format

Parameter	Type	Description
startAt	String	Start date time
endAt	String	End date time
service	String	The service account ID
channelType	String	Channel type name
totalReceivedEnquiry	Integer	The total number of received enquiry
totalOngoingEnquiry	Integer	The total number of ongoing enquiry
totalMissedEnquiry	Integer	The total number of missed enquiry
totalFollowedupEnquiry	Integer	The total number of followed-up enquiry
totalClosedEnquiry	Integer	The total number of closed enquiry
avgRespondDuration	Number	The average enquiry response duration (in Milliseconds)
avgFollowupDuration	Number	The average enquiry followed-up duration (in Milliseconds)
avgCloseDuration	Number	The average enquiry closed duration (in Milliseconds)
totalCalls	Integer	The total number of calls made and received
totalOnnetCalls	Integer	The total number of on-net call
totalOffnetCalls	Integer	The total number of off-net call
channelTypeList	String	A list of channel type
channelTypeEnquiryInfo.total	Integer	The total number of enquiry received from all channels
channelTypeEnquiryInfo.missedcount	Integer	The total number of missed enquiry from the channel
channelTypeEnquiryInfo.elements.name	String	The channel type name
channelTypeEnquiryInfo.elements.count	Integer	The total number of enquiry handled by the channel type
channelTypeEnquiryInfo.elements.percentage	Number	The percentage of enquiry handled by the channel type
channelTypeEnquiryInfo.elements.type	String	Type of elements
channelTypeEnquiryInfo.elements.channalType	String	The channel type name
channelTypeEnquiryInfo.elements.previousMissedCount	Integer	The total number of missed enquiry by the channel type
channelTypeDestinationInfo.total	Integer	The total number of channel type destination handled
channelTypeDestinationInfo.elements.name	String	Destination name
channelTypeDestinationInfo.elements.count	Integer	The total number of enquiry that handled by the destination
channelTypeDestinationInfo.elements.percentage	Number	The percentage of enquiry that handled by the destination
channelTypeDestinationInfo.elements.type	String	Type of elements
channelTypeDestinationInfo.elements.destinationid	String	Destination id
totalVisitors	Integer	The total number visitors
totalNewVisitors	Integer	The total number of new visitors
totalReturnVisitors	Integer	The total number of returned visitors
visitorLocation	String	The visitor location and the number of visitor
cid	String	(Internal use)

Path Params

appID string required
App ID

startAt string required
UTC+0 time string in date only, Example: 2022-03-14T

endAt string required
UTC+0 time string in date only, Example: 2022-03-14T. Max 90 days

Query Params

channelType string
Insert the channel type name for filter. You can find it in the "Get Channel Type list endpoint" response

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/enquiry/overview_matrix?{startAt=}&{endAt=}' \
     --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/enquiry/overview_matrix?{startAt=}&{endAt=}' \
  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/enquiry/overview_matrix?{startAt=}&{endAt=}',
  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/enquiry/overview_matrix?{startAt=}&{endAt=}';
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/enquiry/overview_matrix?{startAt=}&{endAt=}',
  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.getEnquiryOverviewMatrix({
  '{startAt': '}',
  '{endAt': '}',
  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/enquiry/overview_matrix?{startAt=}&{endAt=}")

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/enquiry/overview_matrix?{startAt=}&{endAt=}",
  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/enquiry/overview_matrix?{startAt=}&{endAt=}', [
  '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/enquiry/overview_matrix?{startAt=}&{endAt=}"

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/enquiry/overview_matrix?{startAt=}&{endAt=}");

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/enquiry/overview_matrix?{startAt=}&{endAt=}"),
    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/enquiry/overview_matrix?{startAt=}&{endAt=}");
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/enquiry/overview_matrix?{startAt=}&{endAt=}");

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/enquiry/overview_matrix" {:headers {:Content-Type "application/json"
                                                                                              :Authorization "Bearer AppToken"}
                                                                                    :query-params {:{startAt "}"
                                                                                                   :{endAt "}"}
                                                                                    :accept :json})

LANGUAGE: Go

Request Copy

package main

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

func main() {

	url := "https://examplebaseurl.com/v1/api/apps/appID/enquiry/overview_matrix?{startAt=}&{endAt=}"

	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/enquiry/overview_matrix?{startAt=}&{endAt=} 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/enquiry/overview_matrix?{startAt=}&{endAt=}")
  .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/enquiry/overview_matrix?{startAt=}&{endAt=}"))
    .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/enquiry/overview_matrix?{startAt=}&{endAt=}")
  .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/enquiry/overview_matrix?{startAt=}&{endAt=}")
  .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/enquiry/overview_matrix',
  params: {'{startAt': '}', '{endAt': '}'},
  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/enquiry/overview_matrix?{startAt=}&{endAt=}', 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/enquiry/overview_matrix?{startAt=}&{endAt=}',
  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/enquiry/overview_matrix?{startAt=}&{endAt=}');
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/enquiry/overview_matrix?{startAt=}&{endAt=}")
  .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/enquiry/overview_matrix?{startAt=}&{endAt=}"]
                                                       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/enquiry/overview_matrix?{startAt=}&{endAt=}" 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/enquiry/overview_matrix?{startAt=}&{endAt=}' -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/enquiry/overview_matrix?{startAt=}&{endAt=}' -Method GET -Headers $headers

LANGUAGE: R

Request Copy

library(httr)

url <- "https://examplebaseurl.com/v1/api/apps/appID/enquiry/overview_matrix"

response <- VERB("GET", 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/enquiry/overview_matrix?%7BstartAt=%7D&%7BendAt=%7D")!
var components = URLComponents(url: url, resolvingAgainstBaseURL: true)!
let queryItems: [URLQueryItem] = [
  URLQueryItem(name: "{startAt", value: "}"),
  URLQueryItem(name: "{endAt", value: "}"),
]
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: 200-Result

200-Result Copy

{
    "code": number,
    "result": {
        "startAt": "string",
        "endAt": "string",
        "service": "string",
        "channelType": "string",
        "totalReceivedEnquiry": integer,
        "totalOngoingEnquiry": integer,
        "totalMissedEnquiry": integer,
        "totalFollowedupEnquiry": integer,
        "totalClosedEnquiry": integer,
        "avgRespondDuration": number,
        "avgFollowupDuration": number,
        "avgCloseDuration": number,
        "totalCalls": integer,
        "totalOnnetCalls": integer,
        "totalOffnetCalls": integer,
        "channelTypeList": [
            "string",
            "string",
            "string",
            "string",
            "string"
        ],
        "channelTypeEnquiryInfo": {
            "total": integer,
            "missedCount": integer,
            "elements": [
                {
                    "name": "string",
                    "count": integer,
                    "percentage": number,
                    "type": "string",
                    "channelType": "string",
                    "previousMissedCount": integer
                },
                {
                    "name": "string",
                    "count": integer,
                    "percentage": number,
                    "type": "string",
                    "channelType": "string",
                    "previousMissedCount": integer
                },
            ]
        },
        "channelTypeDestinationInfo": {
            "total": integer,
            "elements": [
                {
                    "name": "string",
                    "count": integer,
                    "percentage": number,
                    "type": "string",
                    "destinationId": "string"
                },
                {
                    "name": "string",
                    "count": integer,
                    "percentage": number,
                    "type": "string",
                    "destinationId": "string"
                },
            ]
        },
        "totalVisitors": integer,
        "totalNewVisitors": integer,
        "totalReturnVisitors": integer,
        "visitorLocation": {
            "HK": integer,
            "TW": integer
        }
    },
    "cid": "string"
}

Response Example

RESPONSE: 400-Result

400-Result Copy

{
  "code": 0,
  "message": "error message from server, please refer to error table"
}

Get SMS Details

Get Channel Type list

Last modified: 2025-12-11

Outline