Menu

Update Tag

PATCH https://examplebaseURL.com/v1/api/apps/{appID}/tag/{tagID}

Response Format

Parameter Type Description
code Number Refer to Success and Error Code
tagId String The ID of the tag which is updated succssfully.
updateAt String The time at which the tag was updated.

📘 Notice

Getting the supported language and destination list first is recommended before creating tags.

  • Refer to Get Supported Language List for the Open API - Get the supported language List.

  • Refer to Get Destination List for the Open API - Get the destination list.

  • For the routing rule, please select one of the following:

    • Alternative routing
    • Time routing with Percentage layer
    • Percentage routing with Time layer

  • It is optional for you to provide the value to the key "buttonPayload", depending on different configurations of the chatbots. For details, please refer to the Auto-Message Message Types section of this Guide.

Path Params

appID string required
App ID

tagID string required
ID of the tag you are required to update.

Body Params

functionType (Required) array of strings
Function enabled for the tag. Available Function types: CALL (call), IM (Chat) or CALL and IM (Call and Chat)

basicInfo object

tagNameLanguageSetting object

welcomeMessage object

timeoutRepeatMessage object

transferFailedMessage object

closingMessage object

routingRule object

stickyRouting boolean Defaults to false
Value = true. Bind a visitor to the staff who handled their enquiry using this tag. Value = false. Do not bind a visitor to the staff who handled their enquiry using this tag.

customChannelInfo object

metaData array of strings
Multiple keywords to be triggered as criteria to show or hide the tag.

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: Shell

Shell: cURL Request Copy 
curl --request PATCH \
     --url https://examplebaseurl.com/v1/api/apps/appID/tag/tagID \
     --header 'Authorization: Bearer AppToken' \
     --header 'Content-Type: application/json' \
     --header 'accept: application/json' \
     --data '
{
  "welcomeMessage": {
    "enabled (Required)": false
  },
  "timeoutRepeatMessage": {
    "enabled (Required)": false
  },
  "transferFailedMessage": {
    "enabled (Required)": false
  },
  "closingMessage": {
    "enabled (Required)": false
  },
  "stickyRouting": false,
  "customChannelInfo": {
    "enabled": false
  }
}
'
Shell: HTTPie Request Copy 
$ brew install httpie
echo '{"welcomeMessage":{"enabled (Required)":false},"timeoutRepeatMessage":{"enabled (Required)":false},"transferFailedMessage":{"enabled (Required)":false},"closingMessage":{"enabled (Required)":false},"stickyRouting":false,"customChannelInfo":{"enabled":false}}' |  \
  http PATCH https://examplebaseurl.com/v1/api/apps/appID/tag/tagID \
  Authorization:'Bearer AppToken' \
  Content-Type:application/json \
  accept:application/json

Language

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/tag/tagID',
  headers: {
    accept: 'application/json',
    'Content-Type': 'application/json',
    Authorization: 'Bearer AppToken'
  },
  data: {
    welcomeMessage: {'enabled (Required)': false},
    timeoutRepeatMessage: {'enabled (Required)': false},
    transferFailedMessage: {'enabled (Required)': false},
    closingMessage: {'enabled (Required)': false},
    stickyRouting: false,
    customChannelInfo: {enabled: false}
  }
};

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/tag/tagID';
const options = {
  method: 'PATCH',
  headers: {
    accept: 'application/json',
    'Content-Type': 'application/json',
    Authorization: 'Bearer AppToken'
  },
  body: JSON.stringify({
    welcomeMessage: {'enabled (Required)': false},
    timeoutRepeatMessage: {'enabled (Required)': false},
    transferFailedMessage: {'enabled (Required)': false},
    closingMessage: {'enabled (Required)': false},
    stickyRouting: false,
    customChannelInfo: {enabled: false}
  })
};

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/tag/tagID',
  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.write(JSON.stringify({
  welcomeMessage: {'enabled (Required)': false},
  timeoutRepeatMessage: {'enabled (Required)': false},
  transferFailedMessage: {'enabled (Required)': false},
  closingMessage: {'enabled (Required)': false},
  stickyRouting: false,
  customChannelInfo: {enabled: false}
}));
req.end();
Node: API Request Copy 
$ npx api install "@cinnox2021/v7.3#45i1wk2km9l1e4hf"
import cinnox2021 from '@api/cinnox2021';

cinnox2021.updateTag2({
  welcomeMessage: {'enabled (Required)': false},
  timeoutRepeatMessage: {'enabled (Required)': false},
  transferFailedMessage: {'enabled (Required)': false},
  closingMessage: {'enabled (Required)': false},
  stickyRouting: false,
  customChannelInfo: {enabled: false}
}, {
  appID: 'appID',
  tagID: 'tagID',
  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/tag/tagID")

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'
request.body = "{\"welcomeMessage\":{\"enabled (Required)\":false},\"timeoutRepeatMessage\":{\"enabled (Required)\":false},\"transferFailedMessage\":{\"enabled (Required)\":false},\"closingMessage\":{\"enabled (Required)\":false},\"stickyRouting\":false,\"customChannelInfo\":{\"enabled\":false}}"

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/tag/tagID",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'welcomeMessage' => [
        'enabled (Required)' => false
    ],
    'timeoutRepeatMessage' => [
        'enabled (Required)' => false
    ],
    'transferFailedMessage' => [
        'enabled (Required)' => false
    ],
    'closingMessage' => [
        'enabled (Required)' => false
    ],
    'stickyRouting' => false,
    'customChannelInfo' => [
        'enabled' => false
    ]
  ]),
  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/tag/tagID', [
  'body' => '{"welcomeMessage":{"enabled (Required)":false},"timeoutRepeatMessage":{"enabled (Required)":false},"transferFailedMessage":{"enabled (Required)":false},"closingMessage":{"enabled (Required)":false},"stickyRouting":false,"customChannelInfo":{"enabled":false}}',
  '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/tag/tagID"

payload = {
    "welcomeMessage": { "enabled (Required)": False },
    "timeoutRepeatMessage": { "enabled (Required)": False },
    "transferFailedMessage": { "enabled (Required)": False },
    "closingMessage": { "enabled (Required)": False },
    "stickyRouting": False,
    "customChannelInfo": { "enabled": False }
}
headers = {
    "accept": "application/json",
    "Content-Type": "application/json",
    "Authorization": "Bearer AppToken"
}

response = requests.patch(url, json=payload, 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/tag/tagID");

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);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\"welcomeMessage\":{\"enabled (Required)\":false},\"timeoutRepeatMessage\":{\"enabled (Required)\":false},\"transferFailedMessage\":{\"enabled (Required)\":false},\"closingMessage\":{\"enabled (Required)\":false},\"stickyRouting\":false,\"customChannelInfo\":{\"enabled\":false}}");

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/tag/tagID"),
    Headers =
    {
        { "accept", "application/json" },
        { "Authorization", "Bearer AppToken" },
    },
    Content = new StringContent("{\"welcomeMessage\":{\"enabled (Required)\":false},\"timeoutRepeatMessage\":{\"enabled (Required)\":false},\"transferFailedMessage\":{\"enabled (Required)\":false},\"closingMessage\":{\"enabled (Required)\":false},\"stickyRouting\":false,\"customChannelInfo\":{\"enabled\":false}}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
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/tag/tagID");
var client = new RestClient(options);
var request = new RestRequest("");
request.AddHeader("accept", "application/json");
request.AddHeader("Authorization", "Bearer AppToken");
request.AddJsonBody("{\"welcomeMessage\":{\"enabled (Required)\":false},\"timeoutRepeatMessage\":{\"enabled (Required)\":false},\"transferFailedMessage\":{\"enabled (Required)\":false},\"closingMessage\":{\"enabled (Required)\":false},\"stickyRouting\":false,\"customChannelInfo\":{\"enabled\":false}}", false);
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/tag/tagID");

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);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\"welcomeMessage\":{\"enabled (Required)\":false},\"timeoutRepeatMessage\":{\"enabled (Required)\":false},\"transferFailedMessage\":{\"enabled (Required)\":false},\"closingMessage\":{\"enabled (Required)\":false},\"stickyRouting\":false,\"customChannelInfo\":{\"enabled\":false}}");

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/tag/tagID" {:headers {:Authorization "Bearer AppToken"}
                                                                        :content-type :json
                                                                        :form-params {:welcomeMessage {:enabled (Required) false}
                                                                                      :timeoutRepeatMessage {:enabled (Required) false}
                                                                                      :transferFailedMessage {:enabled (Required) false}
                                                                                      :closingMessage {:enabled (Required) false}
                                                                                      :stickyRouting false
                                                                                      :customChannelInfo {:enabled false}}
                                                                        :accept :json})

LANGUAGE: Go

Request Copy 
package main

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

func main() {

	url := "https://examplebaseurl.com/v1/api/apps/appID/tag/tagID"

	payload := strings.NewReader("{\"welcomeMessage\":{\"enabled (Required)\":false},\"timeoutRepeatMessage\":{\"enabled (Required)\":false},\"transferFailedMessage\":{\"enabled (Required)\":false},\"closingMessage\":{\"enabled (Required)\":false},\"stickyRouting\":false,\"customChannelInfo\":{\"enabled\":false}}")

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

	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/tag/tagID HTTP/1.1
Accept: application/json
Content-Type: application/json
Authorization: Bearer AppToken
Host: examplebaseurl.com
Content-Length: 258

{"welcomeMessage":{"enabled (Required)":false},"timeoutRepeatMessage":{"enabled (Required)":false},"transferFailedMessage":{"enabled (Required)":false},"closingMessage":{"enabled (Required)":false},"stickyRouting":false,"customChannelInfo":{"enabled":false}}

LANGUAGE: Java

Java: AsyncHttp Request Copy 
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "https://examplebaseurl.com/v1/api/apps/appID/tag/tagID")
  .setHeader("accept", "application/json")
  .setHeader("Content-Type", "application/json")
  .setHeader("Authorization", "Bearer AppToken")
  .setBody("{\"welcomeMessage\":{\"enabled (Required)\":false},\"timeoutRepeatMessage\":{\"enabled (Required)\":false},\"transferFailedMessage\":{\"enabled (Required)\":false},\"closingMessage\":{\"enabled (Required)\":false},\"stickyRouting\":false,\"customChannelInfo\":{\"enabled\":false}}")
  .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/tag/tagID"))
    .header("accept", "application/json")
    .header("Content-Type", "application/json")
    .header("Authorization", "Bearer AppToken")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\"welcomeMessage\":{\"enabled (Required)\":false},\"timeoutRepeatMessage\":{\"enabled (Required)\":false},\"transferFailedMessage\":{\"enabled (Required)\":false},\"closingMessage\":{\"enabled (Required)\":false},\"stickyRouting\":false,\"customChannelInfo\":{\"enabled\":false}}"))
    .build();
HttpResponse<String> response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
Java: OkHttp. Request Copy 
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\"welcomeMessage\":{\"enabled (Required)\":false},\"timeoutRepeatMessage\":{\"enabled (Required)\":false},\"transferFailedMessage\":{\"enabled (Required)\":false},\"closingMessage\":{\"enabled (Required)\":false},\"stickyRouting\":false,\"customChannelInfo\":{\"enabled\":false}}");
Request request = new Request.Builder()
  .url("https://examplebaseurl.com/v1/api/apps/appID/tag/tagID")
  .patch(body)
  .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/tag/tagID")
  .header("accept", "application/json")
  .header("Content-Type", "application/json")
  .header("Authorization", "Bearer AppToken")
  .body("{\"welcomeMessage\":{\"enabled (Required)\":false},\"timeoutRepeatMessage\":{\"enabled (Required)\":false},\"transferFailedMessage\":{\"enabled (Required)\":false},\"closingMessage\":{\"enabled (Required)\":false},\"stickyRouting\":false,\"customChannelInfo\":{\"enabled\":false}}")
  .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/tag/tagID',
  headers: {
    accept: 'application/json',
    'Content-Type': 'application/json',
    Authorization: 'Bearer AppToken'
  },
  data: {
    welcomeMessage: {'enabled (Required)': false},
    timeoutRepeatMessage: {'enabled (Required)': false},
    transferFailedMessage: {'enabled (Required)': false},
    closingMessage: {'enabled (Required)': false},
    stickyRouting: false,
    customChannelInfo: {enabled: false}
  }
};

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'
  },
  body: JSON.stringify({
    welcomeMessage: {'enabled (Required)': false},
    timeoutRepeatMessage: {'enabled (Required)': false},
    transferFailedMessage: {'enabled (Required)': false},
    closingMessage: {'enabled (Required)': false},
    stickyRouting: false,
    customChannelInfo: {enabled: false}
  })
};

fetch('https://examplebaseurl.com/v1/api/apps/appID/tag/tagID', 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/tag/tagID',
  method: 'PATCH',
  headers: {
    accept: 'application/json',
    'Content-Type': 'application/json',
    Authorization: 'Bearer AppToken'
  },
  processData: false,
  data: '{"welcomeMessage":{"enabled (Required)":false},"timeoutRepeatMessage":{"enabled (Required)":false},"transferFailedMessage":{"enabled (Required)":false},"closingMessage":{"enabled (Required)":false},"stickyRouting":false,"customChannelInfo":{"enabled":false}}'
};

$.ajax(settings).done(res => {
  console.log(res);
});
JavaScript: XMLHttpRequest Request Copy 
const data = JSON.stringify({
  welcomeMessage: {
    'enabled (Required)': false
  },
  timeoutRepeatMessage: {
    'enabled (Required)': false
  },
  transferFailedMessage: {
    'enabled (Required)': false
  },
  closingMessage: {
    'enabled (Required)': false
  },
  stickyRouting: false,
  customChannelInfo: {
    enabled: false
  }
});

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/tag/tagID');
xhr.setRequestHeader('accept', 'application/json');
xhr.setRequestHeader('Content-Type', 'application/json');
xhr.setRequestHeader('Authorization', 'Bearer AppToken');

xhr.send(data);

LANGUAGE: JSON

Request Copy 
{
  "welcomeMessage": {
    "enabled (Required)": false
  },
  "timeoutRepeatMessage": {
    "enabled (Required)": false
  },
  "transferFailedMessage": {
    "enabled (Required)": false
  },
  "closingMessage": {
    "enabled (Required)": false
  },
  "stickyRouting": false,
  "customChannelInfo": {
    "enabled": false
  }
}

LANGUAGE: Kotlin

Request Copy 
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\"welcomeMessage\":{\"enabled (Required)\":false},\"timeoutRepeatMessage\":{\"enabled (Required)\":false},\"transferFailedMessage\":{\"enabled (Required)\":false},\"closingMessage\":{\"enabled (Required)\":false},\"stickyRouting\":false,\"customChannelInfo\":{\"enabled\":false}}")
val request = Request.Builder()
  .url("https://examplebaseurl.com/v1/api/apps/appID/tag/tagID")
  .patch(body)
  .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" };
NSDictionary *parameters = @{ @"welcomeMessage": @{ @"enabled (Required)": @NO },
                              @"timeoutRepeatMessage": @{ @"enabled (Required)": @NO },
                              @"transferFailedMessage": @{ @"enabled (Required)": @NO },
                              @"closingMessage": @{ @"enabled (Required)": @NO },
                              @"stickyRouting": @NO,
                              @"customChannelInfo": @{ @"enabled": @NO } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://examplebaseurl.com/v1/api/apps/appID/tag/tagID"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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/tag/tagID" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "application/json");
  ("Content-Type", "application/json");
  ("Authorization", "Bearer AppToken");
] in
let body = Cohttp_lwt_body.of_string "{\"welcomeMessage\":{\"enabled (Required)\":false},\"timeoutRepeatMessage\":{\"enabled (Required)\":false},\"transferFailedMessage\":{\"enabled (Required)\":false},\"closingMessage\":{\"enabled (Required)\":false},\"stickyRouting\":false,\"customChannelInfo\":{\"enabled\":false}}" in

Client.call ~headers ~body `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/tag/tagID' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{"welcomeMessage":{"enabled (Required)":false},"timeoutRepeatMessage":{"enabled (Required)":false},"transferFailedMessage":{"enabled (Required)":false},"closingMessage":{"enabled (Required)":false},"stickyRouting":false,"customChannelInfo":{"enabled":false}}'
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/tag/tagID' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{"welcomeMessage":{"enabled (Required)":false},"timeoutRepeatMessage":{"enabled (Required)":false},"transferFailedMessage":{"enabled (Required)":false},"closingMessage":{"enabled (Required)":false},"stickyRouting":false,"customChannelInfo":{"enabled":false}}'

LANGUAGE: R

Request Copy 
library(httr)

url <- "https://examplebaseurl.com/v1/api/apps/appID/tag/tagID"

payload <- "{\"welcomeMessage\":{\"enabled (Required)\":false},\"timeoutRepeatMessage\":{\"enabled (Required)\":false},\"transferFailedMessage\":{\"enabled (Required)\":false},\"closingMessage\":{\"enabled (Required)\":false},\"stickyRouting\":false,\"customChannelInfo\":{\"enabled\":false}}"

encode <- "json"

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

content(response, "text")

LANGUAGE: Swift

Request Copy 
import Foundation

let parameters = [
  "welcomeMessage": ["enabled (Required)": false],
  "timeoutRepeatMessage": ["enabled (Required)": false],
  "transferFailedMessage": ["enabled (Required)": false],
  "closingMessage": ["enabled (Required)": false],
  "stickyRouting": false,
  "customChannelInfo": ["enabled": false]
] as [String : Any?]

let postData = try JSONSerialization.data(withJSONObject: parameters, options: [])

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

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": {
    "tagId": "string",
    "updateAt": "string"
  }
}

RESPONSE: 400-Result

400-Result Copy 
{
  "code": 0,
  "message": "The error message from the server. Please refer to the error table."
}
Previous
Get Tag List
Next
Delete Tag
Last modified: 2025-12-12