Twilio - Conversations

POST CreateConfigurationAddress

{{baseUrl}}/v1/Configuration/Addresses

BODY formUrlEncoded

Address

AutoCreation.ConversationServiceSid

AutoCreation.Enabled

AutoCreation.StudioFlowSid

AutoCreation.StudioRetryCount

AutoCreation.Type

AutoCreation.WebhookFilters

AutoCreation.WebhookMethod

AutoCreation.WebhookUrl

FriendlyName

Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Configuration/Addresses");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Address=&AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=&Type=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Configuration/Addresses" {:form-params {:Address ""
                                                                                     :AutoCreation.ConversationServiceSid ""
                                                                                     :AutoCreation.Enabled ""
                                                                                     :AutoCreation.StudioFlowSid ""
                                                                                     :AutoCreation.StudioRetryCount ""
                                                                                     :AutoCreation.Type ""
                                                                                     :AutoCreation.WebhookFilters ""
                                                                                     :AutoCreation.WebhookMethod ""
                                                                                     :AutoCreation.WebhookUrl ""
                                                                                     :FriendlyName ""
                                                                                     :Type ""}})

require "http/client"

url = "{{baseUrl}}/v1/Configuration/Addresses"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Address=&AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=&Type="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Configuration/Addresses"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Address", "" },
        { "AutoCreation.ConversationServiceSid", "" },
        { "AutoCreation.Enabled", "" },
        { "AutoCreation.StudioFlowSid", "" },
        { "AutoCreation.StudioRetryCount", "" },
        { "AutoCreation.Type", "" },
        { "AutoCreation.WebhookFilters", "" },
        { "AutoCreation.WebhookMethod", "" },
        { "AutoCreation.WebhookUrl", "" },
        { "FriendlyName", "" },
        { "Type", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Configuration/Addresses");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Address=&AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=&Type=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Configuration/Addresses"

	payload := strings.NewReader("Address=&AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=&Type=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Configuration/Addresses HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 247

Address=&AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=&Type=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Configuration/Addresses")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Address=&AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=&Type=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Configuration/Addresses"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Address=&AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=&Type="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Address=&AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=&Type=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Configuration/Addresses")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Configuration/Addresses")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Address=&AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=&Type=")
  .asString();

const data = 'Address=&AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=&Type=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/Configuration/Addresses');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Address', '');
encodedParams.set('AutoCreation.ConversationServiceSid', '');
encodedParams.set('AutoCreation.Enabled', '');
encodedParams.set('AutoCreation.StudioFlowSid', '');
encodedParams.set('AutoCreation.StudioRetryCount', '');
encodedParams.set('AutoCreation.Type', '');
encodedParams.set('AutoCreation.WebhookFilters', '');
encodedParams.set('AutoCreation.WebhookMethod', '');
encodedParams.set('AutoCreation.WebhookUrl', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Type', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Configuration/Addresses',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Configuration/Addresses';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    Address: '',
    'AutoCreation.ConversationServiceSid': '',
    'AutoCreation.Enabled': '',
    'AutoCreation.StudioFlowSid': '',
    'AutoCreation.StudioRetryCount': '',
    'AutoCreation.Type': '',
    'AutoCreation.WebhookFilters': '',
    'AutoCreation.WebhookMethod': '',
    'AutoCreation.WebhookUrl': '',
    FriendlyName: '',
    Type: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Configuration/Addresses',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Address: '',
    'AutoCreation.ConversationServiceSid': '',
    'AutoCreation.Enabled': '',
    'AutoCreation.StudioFlowSid': '',
    'AutoCreation.StudioRetryCount': '',
    'AutoCreation.Type': '',
    'AutoCreation.WebhookFilters': '',
    'AutoCreation.WebhookMethod': '',
    'AutoCreation.WebhookUrl': '',
    FriendlyName: '',
    Type: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Address=&AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=&Type=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Configuration/Addresses")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Configuration/Addresses',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  Address: '',
  'AutoCreation.ConversationServiceSid': '',
  'AutoCreation.Enabled': '',
  'AutoCreation.StudioFlowSid': '',
  'AutoCreation.StudioRetryCount': '',
  'AutoCreation.Type': '',
  'AutoCreation.WebhookFilters': '',
  'AutoCreation.WebhookMethod': '',
  'AutoCreation.WebhookUrl': '',
  FriendlyName: '',
  Type: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Configuration/Addresses',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    Address: '',
    'AutoCreation.ConversationServiceSid': '',
    'AutoCreation.Enabled': '',
    'AutoCreation.StudioFlowSid': '',
    'AutoCreation.StudioRetryCount': '',
    'AutoCreation.Type': '',
    'AutoCreation.WebhookFilters': '',
    'AutoCreation.WebhookMethod': '',
    'AutoCreation.WebhookUrl': '',
    FriendlyName: '',
    Type: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Configuration/Addresses');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Address: '',
  'AutoCreation.ConversationServiceSid': '',
  'AutoCreation.Enabled': '',
  'AutoCreation.StudioFlowSid': '',
  'AutoCreation.StudioRetryCount': '',
  'AutoCreation.Type': '',
  'AutoCreation.WebhookFilters': '',
  'AutoCreation.WebhookMethod': '',
  'AutoCreation.WebhookUrl': '',
  FriendlyName: '',
  Type: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Address', '');
encodedParams.set('AutoCreation.ConversationServiceSid', '');
encodedParams.set('AutoCreation.Enabled', '');
encodedParams.set('AutoCreation.StudioFlowSid', '');
encodedParams.set('AutoCreation.StudioRetryCount', '');
encodedParams.set('AutoCreation.Type', '');
encodedParams.set('AutoCreation.WebhookFilters', '');
encodedParams.set('AutoCreation.WebhookMethod', '');
encodedParams.set('AutoCreation.WebhookUrl', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Type', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Configuration/Addresses',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Address', '');
encodedParams.set('AutoCreation.ConversationServiceSid', '');
encodedParams.set('AutoCreation.Enabled', '');
encodedParams.set('AutoCreation.StudioFlowSid', '');
encodedParams.set('AutoCreation.StudioRetryCount', '');
encodedParams.set('AutoCreation.Type', '');
encodedParams.set('AutoCreation.WebhookFilters', '');
encodedParams.set('AutoCreation.WebhookMethod', '');
encodedParams.set('AutoCreation.WebhookUrl', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Type', '');

const url = '{{baseUrl}}/v1/Configuration/Addresses';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Address=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AutoCreation.ConversationServiceSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AutoCreation.Enabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AutoCreation.StudioFlowSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AutoCreation.StudioRetryCount=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AutoCreation.Type=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AutoCreation.WebhookFilters=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AutoCreation.WebhookMethod=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AutoCreation.WebhookUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Type=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Configuration/Addresses"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Configuration/Addresses" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Address=&AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=&Type=" in

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

 "{{baseUrl}}/v1/Configuration/Addresses",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Address=&AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=&Type=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Configuration/Addresses', [
  'form_params' => [
    'Address' => '',
    'AutoCreation.ConversationServiceSid' => '',
    'AutoCreation.Enabled' => '',
    'AutoCreation.StudioFlowSid' => '',
    'AutoCreation.StudioRetryCount' => '',
    'AutoCreation.Type' => '',
    'AutoCreation.WebhookFilters' => '',
    'AutoCreation.WebhookMethod' => '',
    'AutoCreation.WebhookUrl' => '',
    'FriendlyName' => '',
    'Type' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Configuration/Addresses');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Address' => '',
  'AutoCreation.ConversationServiceSid' => '',
  'AutoCreation.Enabled' => '',
  'AutoCreation.StudioFlowSid' => '',
  'AutoCreation.StudioRetryCount' => '',
  'AutoCreation.Type' => '',
  'AutoCreation.WebhookFilters' => '',
  'AutoCreation.WebhookMethod' => '',
  'AutoCreation.WebhookUrl' => '',
  'FriendlyName' => '',
  'Type' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Address' => '',
  'AutoCreation.ConversationServiceSid' => '',
  'AutoCreation.Enabled' => '',
  'AutoCreation.StudioFlowSid' => '',
  'AutoCreation.StudioRetryCount' => '',
  'AutoCreation.Type' => '',
  'AutoCreation.WebhookFilters' => '',
  'AutoCreation.WebhookMethod' => '',
  'AutoCreation.WebhookUrl' => '',
  'FriendlyName' => '',
  'Type' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Configuration/Addresses');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Configuration/Addresses' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Address=&AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=&Type='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Configuration/Addresses' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Address=&AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=&Type='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Address=&AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=&Type="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Configuration/Addresses", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Configuration/Addresses"

payload = {
    "Address": "",
    "AutoCreation.ConversationServiceSid": "",
    "AutoCreation.Enabled": "",
    "AutoCreation.StudioFlowSid": "",
    "AutoCreation.StudioRetryCount": "",
    "AutoCreation.Type": "",
    "AutoCreation.WebhookFilters": "",
    "AutoCreation.WebhookMethod": "",
    "AutoCreation.WebhookUrl": "",
    "FriendlyName": "",
    "Type": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Configuration/Addresses"

payload <- "Address=&AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=&Type="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Configuration/Addresses")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Address=&AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=&Type="

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

require 'faraday'

data = {
  :Address => "",
  :AutoCreation.ConversationServiceSid => "",
  :AutoCreation.Enabled => "",
  :AutoCreation.StudioFlowSid => "",
  :AutoCreation.StudioRetryCount => "",
  :AutoCreation.Type => "",
  :AutoCreation.WebhookFilters => "",
  :AutoCreation.WebhookMethod => "",
  :AutoCreation.WebhookUrl => "",
  :FriendlyName => "",
  :Type => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Configuration/Addresses') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Configuration/Addresses";

    let payload = json!({
        "Address": "",
        "AutoCreation.ConversationServiceSid": "",
        "AutoCreation.Enabled": "",
        "AutoCreation.StudioFlowSid": "",
        "AutoCreation.StudioRetryCount": "",
        "AutoCreation.Type": "",
        "AutoCreation.WebhookFilters": "",
        "AutoCreation.WebhookMethod": "",
        "AutoCreation.WebhookUrl": "",
        "FriendlyName": "",
        "Type": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Configuration/Addresses \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Address= \
  --data AutoCreation.ConversationServiceSid= \
  --data AutoCreation.Enabled= \
  --data AutoCreation.StudioFlowSid= \
  --data AutoCreation.StudioRetryCount= \
  --data AutoCreation.Type= \
  --data AutoCreation.WebhookFilters= \
  --data AutoCreation.WebhookMethod= \
  --data AutoCreation.WebhookUrl= \
  --data FriendlyName= \
  --data Type=

http --form POST {{baseUrl}}/v1/Configuration/Addresses \
  content-type:application/x-www-form-urlencoded \
  Address='' \
  AutoCreation.ConversationServiceSid='' \
  AutoCreation.Enabled='' \
  AutoCreation.StudioFlowSid='' \
  AutoCreation.StudioRetryCount='' \
  AutoCreation.Type='' \
  AutoCreation.WebhookFilters='' \
  AutoCreation.WebhookMethod='' \
  AutoCreation.WebhookUrl='' \
  FriendlyName='' \
  Type=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Address=&AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=&Type=' \
  --output-document \
  - {{baseUrl}}/v1/Configuration/Addresses

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Address=".data(using: String.Encoding.utf8)!)
postData.append("&AutoCreation.ConversationServiceSid=".data(using: String.Encoding.utf8)!)
postData.append("&AutoCreation.Enabled=".data(using: String.Encoding.utf8)!)
postData.append("&AutoCreation.StudioFlowSid=".data(using: String.Encoding.utf8)!)
postData.append("&AutoCreation.StudioRetryCount=".data(using: String.Encoding.utf8)!)
postData.append("&AutoCreation.Type=".data(using: String.Encoding.utf8)!)
postData.append("&AutoCreation.WebhookFilters=".data(using: String.Encoding.utf8)!)
postData.append("&AutoCreation.WebhookMethod=".data(using: String.Encoding.utf8)!)
postData.append("&AutoCreation.WebhookUrl=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&Type=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Configuration/Addresses")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateConversation

{{baseUrl}}/v1/Conversations

BODY formUrlEncoded

Attributes

DateCreated

DateUpdated

FriendlyName

MessagingServiceSid

State

Timers.Closed

Timers.Inactive

UniqueName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Conversations" {:form-params {:Attributes ""
                                                                           :DateCreated ""
                                                                           :DateUpdated ""
                                                                           :FriendlyName ""
                                                                           :MessagingServiceSid ""
                                                                           :State ""
                                                                           :Timers.Closed ""
                                                                           :Timers.Inactive ""
                                                                           :UniqueName ""}})

require "http/client"

url = "{{baseUrl}}/v1/Conversations"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "DateCreated", "" },
        { "DateUpdated", "" },
        { "FriendlyName", "" },
        { "MessagingServiceSid", "" },
        { "State", "" },
        { "Timers.Closed", "" },
        { "Timers.Inactive", "" },
        { "UniqueName", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Conversations"

	payload := strings.NewReader("Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Conversations HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 123

Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Conversations")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Conversations")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=")
  .asString();

const data = 'Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/Conversations');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('MessagingServiceSid', '');
encodedParams.set('State', '');
encodedParams.set('Timers.Closed', '');
encodedParams.set('Timers.Inactive', '');
encodedParams.set('UniqueName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    FriendlyName: '',
    MessagingServiceSid: '',
    State: '',
    'Timers.Closed': '',
    'Timers.Inactive': '',
    UniqueName: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    FriendlyName: '',
    MessagingServiceSid: '',
    State: '',
    'Timers.Closed': '',
    'Timers.Inactive': '',
    UniqueName: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  Attributes: '',
  DateCreated: '',
  DateUpdated: '',
  FriendlyName: '',
  MessagingServiceSid: '',
  State: '',
  'Timers.Closed': '',
  'Timers.Inactive': '',
  UniqueName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    FriendlyName: '',
    MessagingServiceSid: '',
    State: '',
    'Timers.Closed': '',
    'Timers.Inactive': '',
    UniqueName: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Conversations');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Attributes: '',
  DateCreated: '',
  DateUpdated: '',
  FriendlyName: '',
  MessagingServiceSid: '',
  State: '',
  'Timers.Closed': '',
  'Timers.Inactive': '',
  UniqueName: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('MessagingServiceSid', '');
encodedParams.set('State', '');
encodedParams.set('Timers.Closed', '');
encodedParams.set('Timers.Inactive', '');
encodedParams.set('UniqueName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('MessagingServiceSid', '');
encodedParams.set('State', '');
encodedParams.set('Timers.Closed', '');
encodedParams.set('Timers.Inactive', '');
encodedParams.set('UniqueName', '');

const url = '{{baseUrl}}/v1/Conversations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateCreated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateUpdated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MessagingServiceSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&State=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Timers.Closed=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Timers.Inactive=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UniqueName=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=" in

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

 "{{baseUrl}}/v1/Conversations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Conversations', [
  'form_params' => [
    'Attributes' => '',
    'DateCreated' => '',
    'DateUpdated' => '',
    'FriendlyName' => '',
    'MessagingServiceSid' => '',
    'State' => '',
    'Timers.Closed' => '',
    'Timers.Inactive' => '',
    'UniqueName' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Attributes' => '',
  'DateCreated' => '',
  'DateUpdated' => '',
  'FriendlyName' => '',
  'MessagingServiceSid' => '',
  'State' => '',
  'Timers.Closed' => '',
  'Timers.Inactive' => '',
  'UniqueName' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Attributes' => '',
  'DateCreated' => '',
  'DateUpdated' => '',
  'FriendlyName' => '',
  'MessagingServiceSid' => '',
  'State' => '',
  'Timers.Closed' => '',
  'Timers.Inactive' => '',
  'UniqueName' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Conversations');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Conversations", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations"

payload = {
    "Attributes": "",
    "DateCreated": "",
    "DateUpdated": "",
    "FriendlyName": "",
    "MessagingServiceSid": "",
    "State": "",
    "Timers.Closed": "",
    "Timers.Inactive": "",
    "UniqueName": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations"

payload <- "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName="

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

require 'faraday'

data = {
  :Attributes => "",
  :DateCreated => "",
  :DateUpdated => "",
  :FriendlyName => "",
  :MessagingServiceSid => "",
  :State => "",
  :Timers.Closed => "",
  :Timers.Inactive => "",
  :UniqueName => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Conversations') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations";

    let payload = json!({
        "Attributes": "",
        "DateCreated": "",
        "DateUpdated": "",
        "FriendlyName": "",
        "MessagingServiceSid": "",
        "State": "",
        "Timers.Closed": "",
        "Timers.Inactive": "",
        "UniqueName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Conversations \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data DateCreated= \
  --data DateUpdated= \
  --data FriendlyName= \
  --data MessagingServiceSid= \
  --data State= \
  --data Timers.Closed= \
  --data Timers.Inactive= \
  --data UniqueName=

http --form POST {{baseUrl}}/v1/Conversations \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  DateCreated='' \
  DateUpdated='' \
  FriendlyName='' \
  MessagingServiceSid='' \
  State='' \
  Timers.Closed='' \
  Timers.Inactive='' \
  UniqueName=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=' \
  --output-document \
  - {{baseUrl}}/v1/Conversations

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&DateCreated=".data(using: String.Encoding.utf8)!)
postData.append("&DateUpdated=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&MessagingServiceSid=".data(using: String.Encoding.utf8)!)
postData.append("&State=".data(using: String.Encoding.utf8)!)
postData.append("&Timers.Closed=".data(using: String.Encoding.utf8)!)
postData.append("&Timers.Inactive=".data(using: String.Encoding.utf8)!)
postData.append("&UniqueName=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateConversationMessage

{{baseUrl}}/v1/Conversations/:ConversationSid/Messages

QUERY PARAMS

ConversationSid

BODY formUrlEncoded

Attributes

Author

Body

ContentSid

ContentVariables

DateCreated

DateUpdated

MediaSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages" {:form-params {:Attributes ""
                                                                                                     :Author ""
                                                                                                     :Body ""
                                                                                                     :ContentSid ""
                                                                                                     :ContentVariables ""
                                                                                                     :DateCreated ""
                                                                                                     :DateUpdated ""
                                                                                                     :MediaSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "Author", "" },
        { "Body", "" },
        { "ContentSid", "" },
        { "ContentVariables", "" },
        { "DateCreated", "" },
        { "DateUpdated", "" },
        { "MediaSid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages"

	payload := strings.NewReader("Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Conversations/:ConversationSid/Messages HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 91

Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=")
  .asString();

const data = 'Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('Author', '');
encodedParams.set('Body', '');
encodedParams.set('ContentSid', '');
encodedParams.set('ContentVariables', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('MediaSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    Attributes: '',
    Author: '',
    Body: '',
    ContentSid: '',
    ContentVariables: '',
    DateCreated: '',
    DateUpdated: '',
    MediaSid: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    Author: '',
    Body: '',
    ContentSid: '',
    ContentVariables: '',
    DateCreated: '',
    DateUpdated: '',
    MediaSid: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations/:ConversationSid/Messages',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  Attributes: '',
  Author: '',
  Body: '',
  ContentSid: '',
  ContentVariables: '',
  DateCreated: '',
  DateUpdated: '',
  MediaSid: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    Attributes: '',
    Author: '',
    Body: '',
    ContentSid: '',
    ContentVariables: '',
    DateCreated: '',
    DateUpdated: '',
    MediaSid: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Attributes: '',
  Author: '',
  Body: '',
  ContentSid: '',
  ContentVariables: '',
  DateCreated: '',
  DateUpdated: '',
  MediaSid: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('Author', '');
encodedParams.set('Body', '');
encodedParams.set('ContentSid', '');
encodedParams.set('ContentVariables', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('MediaSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('Author', '');
encodedParams.set('Body', '');
encodedParams.set('ContentSid', '');
encodedParams.set('ContentVariables', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('MediaSid', '');

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Author=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Body=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ContentSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ContentVariables=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateCreated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateUpdated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MediaSid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations/:ConversationSid/Messages"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=" in

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

 "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages', [
  'form_params' => [
    'Attributes' => '',
    'Author' => '',
    'Body' => '',
    'ContentSid' => '',
    'ContentVariables' => '',
    'DateCreated' => '',
    'DateUpdated' => '',
    'MediaSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Messages');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Attributes' => '',
  'Author' => '',
  'Body' => '',
  'ContentSid' => '',
  'ContentVariables' => '',
  'DateCreated' => '',
  'DateUpdated' => '',
  'MediaSid' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Attributes' => '',
  'Author' => '',
  'Body' => '',
  'ContentSid' => '',
  'ContentVariables' => '',
  'DateCreated' => '',
  'DateUpdated' => '',
  'MediaSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Messages');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Conversations/:ConversationSid/Messages", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages"

payload = {
    "Attributes": "",
    "Author": "",
    "Body": "",
    "ContentSid": "",
    "ContentVariables": "",
    "DateCreated": "",
    "DateUpdated": "",
    "MediaSid": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages"

payload <- "Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid="

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

require 'faraday'

data = {
  :Attributes => "",
  :Author => "",
  :Body => "",
  :ContentSid => "",
  :ContentVariables => "",
  :DateCreated => "",
  :DateUpdated => "",
  :MediaSid => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Conversations/:ConversationSid/Messages') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages";

    let payload = json!({
        "Attributes": "",
        "Author": "",
        "Body": "",
        "ContentSid": "",
        "ContentVariables": "",
        "DateCreated": "",
        "DateUpdated": "",
        "MediaSid": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Conversations/:ConversationSid/Messages \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data Author= \
  --data Body= \
  --data ContentSid= \
  --data ContentVariables= \
  --data DateCreated= \
  --data DateUpdated= \
  --data MediaSid=

http --form POST {{baseUrl}}/v1/Conversations/:ConversationSid/Messages \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  Author='' \
  Body='' \
  ContentSid='' \
  ContentVariables='' \
  DateCreated='' \
  DateUpdated='' \
  MediaSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=' \
  --output-document \
  - {{baseUrl}}/v1/Conversations/:ConversationSid/Messages

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&Author=".data(using: String.Encoding.utf8)!)
postData.append("&Body=".data(using: String.Encoding.utf8)!)
postData.append("&ContentSid=".data(using: String.Encoding.utf8)!)
postData.append("&ContentVariables=".data(using: String.Encoding.utf8)!)
postData.append("&DateCreated=".data(using: String.Encoding.utf8)!)
postData.append("&DateUpdated=".data(using: String.Encoding.utf8)!)
postData.append("&MediaSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateConversationParticipant

{{baseUrl}}/v1/Conversations/:ConversationSid/Participants

QUERY PARAMS

ConversationSid

BODY formUrlEncoded

Attributes

DateCreated

DateUpdated

Identity

MessagingBinding.Address

MessagingBinding.ProjectedAddress

MessagingBinding.ProxyAddress

RoleSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants" {:form-params {:Attributes ""
                                                                                                         :DateCreated ""
                                                                                                         :DateUpdated ""
                                                                                                         :Identity ""
                                                                                                         :MessagingBinding.Address ""
                                                                                                         :MessagingBinding.ProjectedAddress ""
                                                                                                         :MessagingBinding.ProxyAddress ""
                                                                                                         :RoleSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "DateCreated", "" },
        { "DateUpdated", "" },
        { "Identity", "" },
        { "MessagingBinding.Address", "" },
        { "MessagingBinding.ProjectedAddress", "" },
        { "MessagingBinding.ProxyAddress", "" },
        { "RoleSid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants"

	payload := strings.NewReader("Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Conversations/:ConversationSid/Participants HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 148

Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=")
  .asString();

const data = 'Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('Identity', '');
encodedParams.set('MessagingBinding.Address', '');
encodedParams.set('MessagingBinding.ProjectedAddress', '');
encodedParams.set('MessagingBinding.ProxyAddress', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    Identity: '',
    'MessagingBinding.Address': '',
    'MessagingBinding.ProjectedAddress': '',
    'MessagingBinding.ProxyAddress': '',
    RoleSid: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    Identity: '',
    'MessagingBinding.Address': '',
    'MessagingBinding.ProjectedAddress': '',
    'MessagingBinding.ProxyAddress': '',
    RoleSid: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations/:ConversationSid/Participants',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  Attributes: '',
  DateCreated: '',
  DateUpdated: '',
  Identity: '',
  'MessagingBinding.Address': '',
  'MessagingBinding.ProjectedAddress': '',
  'MessagingBinding.ProxyAddress': '',
  RoleSid: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    Identity: '',
    'MessagingBinding.Address': '',
    'MessagingBinding.ProjectedAddress': '',
    'MessagingBinding.ProxyAddress': '',
    RoleSid: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Attributes: '',
  DateCreated: '',
  DateUpdated: '',
  Identity: '',
  'MessagingBinding.Address': '',
  'MessagingBinding.ProjectedAddress': '',
  'MessagingBinding.ProxyAddress': '',
  RoleSid: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('Identity', '');
encodedParams.set('MessagingBinding.Address', '');
encodedParams.set('MessagingBinding.ProjectedAddress', '');
encodedParams.set('MessagingBinding.ProxyAddress', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('Identity', '');
encodedParams.set('MessagingBinding.Address', '');
encodedParams.set('MessagingBinding.ProjectedAddress', '');
encodedParams.set('MessagingBinding.ProxyAddress', '');
encodedParams.set('RoleSid', '');

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateCreated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateUpdated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Identity=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MessagingBinding.Address=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MessagingBinding.ProjectedAddress=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MessagingBinding.ProxyAddress=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&RoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations/:ConversationSid/Participants"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=" in

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

 "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants', [
  'form_params' => [
    'Attributes' => '',
    'DateCreated' => '',
    'DateUpdated' => '',
    'Identity' => '',
    'MessagingBinding.Address' => '',
    'MessagingBinding.ProjectedAddress' => '',
    'MessagingBinding.ProxyAddress' => '',
    'RoleSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Participants');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Attributes' => '',
  'DateCreated' => '',
  'DateUpdated' => '',
  'Identity' => '',
  'MessagingBinding.Address' => '',
  'MessagingBinding.ProjectedAddress' => '',
  'MessagingBinding.ProxyAddress' => '',
  'RoleSid' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Attributes' => '',
  'DateCreated' => '',
  'DateUpdated' => '',
  'Identity' => '',
  'MessagingBinding.Address' => '',
  'MessagingBinding.ProjectedAddress' => '',
  'MessagingBinding.ProxyAddress' => '',
  'RoleSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Participants');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Conversations/:ConversationSid/Participants", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants"

payload = {
    "Attributes": "",
    "DateCreated": "",
    "DateUpdated": "",
    "Identity": "",
    "MessagingBinding.Address": "",
    "MessagingBinding.ProjectedAddress": "",
    "MessagingBinding.ProxyAddress": "",
    "RoleSid": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants"

payload <- "Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid="

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

require 'faraday'

data = {
  :Attributes => "",
  :DateCreated => "",
  :DateUpdated => "",
  :Identity => "",
  :MessagingBinding.Address => "",
  :MessagingBinding.ProjectedAddress => "",
  :MessagingBinding.ProxyAddress => "",
  :RoleSid => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Conversations/:ConversationSid/Participants') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants";

    let payload = json!({
        "Attributes": "",
        "DateCreated": "",
        "DateUpdated": "",
        "Identity": "",
        "MessagingBinding.Address": "",
        "MessagingBinding.ProjectedAddress": "",
        "MessagingBinding.ProxyAddress": "",
        "RoleSid": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Conversations/:ConversationSid/Participants \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data DateCreated= \
  --data DateUpdated= \
  --data Identity= \
  --data MessagingBinding.Address= \
  --data MessagingBinding.ProjectedAddress= \
  --data MessagingBinding.ProxyAddress= \
  --data RoleSid=

http --form POST {{baseUrl}}/v1/Conversations/:ConversationSid/Participants \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  DateCreated='' \
  DateUpdated='' \
  Identity='' \
  MessagingBinding.Address='' \
  MessagingBinding.ProjectedAddress='' \
  MessagingBinding.ProxyAddress='' \
  RoleSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=' \
  --output-document \
  - {{baseUrl}}/v1/Conversations/:ConversationSid/Participants

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&DateCreated=".data(using: String.Encoding.utf8)!)
postData.append("&DateUpdated=".data(using: String.Encoding.utf8)!)
postData.append("&Identity=".data(using: String.Encoding.utf8)!)
postData.append("&MessagingBinding.Address=".data(using: String.Encoding.utf8)!)
postData.append("&MessagingBinding.ProjectedAddress=".data(using: String.Encoding.utf8)!)
postData.append("&MessagingBinding.ProxyAddress=".data(using: String.Encoding.utf8)!)
postData.append("&RoleSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateConversationScopedWebhook

{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks

QUERY PARAMS

ConversationSid

BODY formUrlEncoded

Configuration.Filters

Configuration.FlowSid

Configuration.Method

Configuration.ReplayAfter

Configuration.Triggers

Configuration.Url

Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks" {:form-params {:Configuration.Filters ""
                                                                                                     :Configuration.FlowSid ""
                                                                                                     :Configuration.Method ""
                                                                                                     :Configuration.ReplayAfter ""
                                                                                                     :Configuration.Triggers ""
                                                                                                     :Configuration.Url ""
                                                                                                     :Target ""}})

require "http/client"

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Configuration.Filters", "" },
        { "Configuration.FlowSid", "" },
        { "Configuration.Method", "" },
        { "Configuration.ReplayAfter", "" },
        { "Configuration.Triggers", "" },
        { "Configuration.Url", "" },
        { "Target", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks"

	payload := strings.NewReader("Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Conversations/:ConversationSid/Webhooks HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 145

Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=")
  .asString();

const data = 'Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Configuration.Filters', '');
encodedParams.set('Configuration.FlowSid', '');
encodedParams.set('Configuration.Method', '');
encodedParams.set('Configuration.ReplayAfter', '');
encodedParams.set('Configuration.Triggers', '');
encodedParams.set('Configuration.Url', '');
encodedParams.set('Target', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    'Configuration.Filters': '',
    'Configuration.FlowSid': '',
    'Configuration.Method': '',
    'Configuration.ReplayAfter': '',
    'Configuration.Triggers': '',
    'Configuration.Url': '',
    Target: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    'Configuration.Filters': '',
    'Configuration.FlowSid': '',
    'Configuration.Method': '',
    'Configuration.ReplayAfter': '',
    'Configuration.Triggers': '',
    'Configuration.Url': '',
    Target: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations/:ConversationSid/Webhooks',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  'Configuration.Filters': '',
  'Configuration.FlowSid': '',
  'Configuration.Method': '',
  'Configuration.ReplayAfter': '',
  'Configuration.Triggers': '',
  'Configuration.Url': '',
  Target: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    'Configuration.Filters': '',
    'Configuration.FlowSid': '',
    'Configuration.Method': '',
    'Configuration.ReplayAfter': '',
    'Configuration.Triggers': '',
    'Configuration.Url': '',
    Target: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  'Configuration.Filters': '',
  'Configuration.FlowSid': '',
  'Configuration.Method': '',
  'Configuration.ReplayAfter': '',
  'Configuration.Triggers': '',
  'Configuration.Url': '',
  Target: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Configuration.Filters', '');
encodedParams.set('Configuration.FlowSid', '');
encodedParams.set('Configuration.Method', '');
encodedParams.set('Configuration.ReplayAfter', '');
encodedParams.set('Configuration.Triggers', '');
encodedParams.set('Configuration.Url', '');
encodedParams.set('Target', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Configuration.Filters', '');
encodedParams.set('Configuration.FlowSid', '');
encodedParams.set('Configuration.Method', '');
encodedParams.set('Configuration.ReplayAfter', '');
encodedParams.set('Configuration.Triggers', '');
encodedParams.set('Configuration.Url', '');
encodedParams.set('Target', '');

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Configuration.Filters=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Configuration.FlowSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Configuration.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Configuration.ReplayAfter=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Configuration.Triggers=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Configuration.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Target=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=" in

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

 "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks', [
  'form_params' => [
    'Configuration.Filters' => '',
    'Configuration.FlowSid' => '',
    'Configuration.Method' => '',
    'Configuration.ReplayAfter' => '',
    'Configuration.Triggers' => '',
    'Configuration.Url' => '',
    'Target' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Configuration.Filters' => '',
  'Configuration.FlowSid' => '',
  'Configuration.Method' => '',
  'Configuration.ReplayAfter' => '',
  'Configuration.Triggers' => '',
  'Configuration.Url' => '',
  'Target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Configuration.Filters' => '',
  'Configuration.FlowSid' => '',
  'Configuration.Method' => '',
  'Configuration.ReplayAfter' => '',
  'Configuration.Triggers' => '',
  'Configuration.Url' => '',
  'Target' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Conversations/:ConversationSid/Webhooks", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks"

payload = {
    "Configuration.Filters": "",
    "Configuration.FlowSid": "",
    "Configuration.Method": "",
    "Configuration.ReplayAfter": "",
    "Configuration.Triggers": "",
    "Configuration.Url": "",
    "Target": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks"

payload <- "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target="

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

require 'faraday'

data = {
  :Configuration.Filters => "",
  :Configuration.FlowSid => "",
  :Configuration.Method => "",
  :Configuration.ReplayAfter => "",
  :Configuration.Triggers => "",
  :Configuration.Url => "",
  :Target => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Conversations/:ConversationSid/Webhooks') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks";

    let payload = json!({
        "Configuration.Filters": "",
        "Configuration.FlowSid": "",
        "Configuration.Method": "",
        "Configuration.ReplayAfter": "",
        "Configuration.Triggers": "",
        "Configuration.Url": "",
        "Target": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Configuration.Filters= \
  --data Configuration.FlowSid= \
  --data Configuration.Method= \
  --data Configuration.ReplayAfter= \
  --data Configuration.Triggers= \
  --data Configuration.Url= \
  --data Target=

http --form POST {{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks \
  content-type:application/x-www-form-urlencoded \
  Configuration.Filters='' \
  Configuration.FlowSid='' \
  Configuration.Method='' \
  Configuration.ReplayAfter='' \
  Configuration.Triggers='' \
  Configuration.Url='' \
  Target=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=' \
  --output-document \
  - {{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Configuration.Filters=".data(using: String.Encoding.utf8)!)
postData.append("&Configuration.FlowSid=".data(using: String.Encoding.utf8)!)
postData.append("&Configuration.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Configuration.ReplayAfter=".data(using: String.Encoding.utf8)!)
postData.append("&Configuration.Triggers=".data(using: String.Encoding.utf8)!)
postData.append("&Configuration.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Target=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateCredential

{{baseUrl}}/v1/Credentials

BODY formUrlEncoded

ApiKey

Certificate

FriendlyName

PrivateKey

Sandbox

Secret

Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Credentials");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Credentials" {:form-params {:ApiKey ""
                                                                         :Certificate ""
                                                                         :FriendlyName ""
                                                                         :PrivateKey ""
                                                                         :Sandbox ""
                                                                         :Secret ""
                                                                         :Type ""}})

require "http/client"

url = "{{baseUrl}}/v1/Credentials"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Credentials"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "ApiKey", "" },
        { "Certificate", "" },
        { "FriendlyName", "" },
        { "PrivateKey", "" },
        { "Sandbox", "" },
        { "Secret", "" },
        { "Type", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Credentials");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Credentials"

	payload := strings.NewReader("ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Credentials HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 69

ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Credentials")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Credentials"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Credentials")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Credentials")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=")
  .asString();

const data = 'ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/Credentials');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('ApiKey', '');
encodedParams.set('Certificate', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('PrivateKey', '');
encodedParams.set('Sandbox', '');
encodedParams.set('Secret', '');
encodedParams.set('Type', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Credentials',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Credentials';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    ApiKey: '',
    Certificate: '',
    FriendlyName: '',
    PrivateKey: '',
    Sandbox: '',
    Secret: '',
    Type: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Credentials',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    ApiKey: '',
    Certificate: '',
    FriendlyName: '',
    PrivateKey: '',
    Sandbox: '',
    Secret: '',
    Type: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Credentials")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Credentials',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  ApiKey: '',
  Certificate: '',
  FriendlyName: '',
  PrivateKey: '',
  Sandbox: '',
  Secret: '',
  Type: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Credentials',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    ApiKey: '',
    Certificate: '',
    FriendlyName: '',
    PrivateKey: '',
    Sandbox: '',
    Secret: '',
    Type: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Credentials');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  ApiKey: '',
  Certificate: '',
  FriendlyName: '',
  PrivateKey: '',
  Sandbox: '',
  Secret: '',
  Type: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('ApiKey', '');
encodedParams.set('Certificate', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('PrivateKey', '');
encodedParams.set('Sandbox', '');
encodedParams.set('Secret', '');
encodedParams.set('Type', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Credentials',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('ApiKey', '');
encodedParams.set('Certificate', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('PrivateKey', '');
encodedParams.set('Sandbox', '');
encodedParams.set('Secret', '');
encodedParams.set('Type', '');

const url = '{{baseUrl}}/v1/Credentials';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"ApiKey=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Certificate=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&PrivateKey=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Sandbox=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Secret=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Type=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Credentials"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Credentials" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=" in

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

 "{{baseUrl}}/v1/Credentials",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Credentials', [
  'form_params' => [
    'ApiKey' => '',
    'Certificate' => '',
    'FriendlyName' => '',
    'PrivateKey' => '',
    'Sandbox' => '',
    'Secret' => '',
    'Type' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Credentials');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'ApiKey' => '',
  'Certificate' => '',
  'FriendlyName' => '',
  'PrivateKey' => '',
  'Sandbox' => '',
  'Secret' => '',
  'Type' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'ApiKey' => '',
  'Certificate' => '',
  'FriendlyName' => '',
  'PrivateKey' => '',
  'Sandbox' => '',
  'Secret' => '',
  'Type' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Credentials');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Credentials' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Credentials' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Credentials", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Credentials"

payload = {
    "ApiKey": "",
    "Certificate": "",
    "FriendlyName": "",
    "PrivateKey": "",
    "Sandbox": "",
    "Secret": "",
    "Type": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Credentials"

payload <- "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Credentials")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type="

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

require 'faraday'

data = {
  :ApiKey => "",
  :Certificate => "",
  :FriendlyName => "",
  :PrivateKey => "",
  :Sandbox => "",
  :Secret => "",
  :Type => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Credentials') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Credentials";

    let payload = json!({
        "ApiKey": "",
        "Certificate": "",
        "FriendlyName": "",
        "PrivateKey": "",
        "Sandbox": "",
        "Secret": "",
        "Type": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Credentials \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data ApiKey= \
  --data Certificate= \
  --data FriendlyName= \
  --data PrivateKey= \
  --data Sandbox= \
  --data Secret= \
  --data Type=

http --form POST {{baseUrl}}/v1/Credentials \
  content-type:application/x-www-form-urlencoded \
  ApiKey='' \
  Certificate='' \
  FriendlyName='' \
  PrivateKey='' \
  Sandbox='' \
  Secret='' \
  Type=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=' \
  --output-document \
  - {{baseUrl}}/v1/Credentials

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "ApiKey=".data(using: String.Encoding.utf8)!)
postData.append("&Certificate=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&PrivateKey=".data(using: String.Encoding.utf8)!)
postData.append("&Sandbox=".data(using: String.Encoding.utf8)!)
postData.append("&Secret=".data(using: String.Encoding.utf8)!)
postData.append("&Type=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Credentials")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateRole

{{baseUrl}}/v1/Roles

BODY formUrlEncoded

FriendlyName

Permission

Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Roles");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "FriendlyName=&Permission=&Type=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Roles" {:form-params {:FriendlyName ""
                                                                   :Permission ""
                                                                   :Type ""}})

require "http/client"

url = "{{baseUrl}}/v1/Roles"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "FriendlyName=&Permission=&Type="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Roles"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "FriendlyName", "" },
        { "Permission", "" },
        { "Type", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Roles");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "FriendlyName=&Permission=&Type=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Roles"

	payload := strings.NewReader("FriendlyName=&Permission=&Type=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Roles HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 31

FriendlyName=&Permission=&Type=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Roles")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("FriendlyName=&Permission=&Type=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Roles"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("FriendlyName=&Permission=&Type="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "FriendlyName=&Permission=&Type=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Roles")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Roles")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("FriendlyName=&Permission=&Type=")
  .asString();

const data = 'FriendlyName=&Permission=&Type=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/Roles');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('FriendlyName', '');
encodedParams.set('Permission', '');
encodedParams.set('Type', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Roles',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Roles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({FriendlyName: '', Permission: '', Type: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Roles',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    FriendlyName: '',
    Permission: '',
    Type: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "FriendlyName=&Permission=&Type=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Roles")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Roles',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({FriendlyName: '', Permission: '', Type: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Roles',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {FriendlyName: '', Permission: '', Type: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Roles');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  FriendlyName: '',
  Permission: '',
  Type: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('FriendlyName', '');
encodedParams.set('Permission', '');
encodedParams.set('Type', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Roles',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('FriendlyName', '');
encodedParams.set('Permission', '');
encodedParams.set('Type', '');

const url = '{{baseUrl}}/v1/Roles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Permission=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Type=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Roles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Roles" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "FriendlyName=&Permission=&Type=" in

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

 "{{baseUrl}}/v1/Roles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "FriendlyName=&Permission=&Type=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Roles', [
  'form_params' => [
    'FriendlyName' => '',
    'Permission' => '',
    'Type' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Roles');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'FriendlyName' => '',
  'Permission' => '',
  'Type' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'FriendlyName' => '',
  'Permission' => '',
  'Type' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Roles');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Roles' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'FriendlyName=&Permission=&Type='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Roles' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'FriendlyName=&Permission=&Type='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "FriendlyName=&Permission=&Type="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Roles", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Roles"

payload = {
    "FriendlyName": "",
    "Permission": "",
    "Type": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Roles"

payload <- "FriendlyName=&Permission=&Type="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Roles")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "FriendlyName=&Permission=&Type="

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

require 'faraday'

data = {
  :FriendlyName => "",
  :Permission => "",
  :Type => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Roles') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Roles";

    let payload = json!({
        "FriendlyName": "",
        "Permission": "",
        "Type": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Roles \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data FriendlyName= \
  --data Permission= \
  --data Type=

http --form POST {{baseUrl}}/v1/Roles \
  content-type:application/x-www-form-urlencoded \
  FriendlyName='' \
  Permission='' \
  Type=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'FriendlyName=&Permission=&Type=' \
  --output-document \
  - {{baseUrl}}/v1/Roles

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&Permission=".data(using: String.Encoding.utf8)!)
postData.append("&Type=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Roles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateService

{{baseUrl}}/v1/Services

BODY formUrlEncoded

FriendlyName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "FriendlyName=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services" {:form-params {:FriendlyName ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "FriendlyName="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "FriendlyName", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "FriendlyName=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services"

	payload := strings.NewReader("FriendlyName=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Services HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 13

FriendlyName=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("FriendlyName=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("FriendlyName="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "FriendlyName=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("FriendlyName=")
  .asString();

const data = 'FriendlyName=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/Services');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('FriendlyName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({FriendlyName: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    FriendlyName: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "FriendlyName=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({FriendlyName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {FriendlyName: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Services');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  FriendlyName: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('FriendlyName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('FriendlyName', '');

const url = '{{baseUrl}}/v1/Services';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "FriendlyName=" in

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

 "{{baseUrl}}/v1/Services",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "FriendlyName=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Services', [
  'form_params' => [
    'FriendlyName' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'FriendlyName' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'FriendlyName' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'FriendlyName='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'FriendlyName='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "FriendlyName="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services"

payload = { "FriendlyName": "" }
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services"

payload <- "FriendlyName="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "FriendlyName="

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

require 'faraday'

data = {
  :FriendlyName => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services";

    let payload = json!({"FriendlyName": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data FriendlyName=

http --form POST {{baseUrl}}/v1/Services \
  content-type:application/x-www-form-urlencoded \
  FriendlyName=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data FriendlyName= \
  --output-document \
  - {{baseUrl}}/v1/Services

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "FriendlyName=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateServiceConversation

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations

QUERY PARAMS

ChatServiceSid

BODY formUrlEncoded

Attributes

DateCreated

DateUpdated

FriendlyName

MessagingServiceSid

State

Timers.Closed

Timers.Inactive

UniqueName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations" {:form-params {:Attributes ""
                                                                                                    :DateCreated ""
                                                                                                    :DateUpdated ""
                                                                                                    :FriendlyName ""
                                                                                                    :MessagingServiceSid ""
                                                                                                    :State ""
                                                                                                    :Timers.Closed ""
                                                                                                    :Timers.Inactive ""
                                                                                                    :UniqueName ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "DateCreated", "" },
        { "DateUpdated", "" },
        { "FriendlyName", "" },
        { "MessagingServiceSid", "" },
        { "State", "" },
        { "Timers.Closed", "" },
        { "Timers.Inactive", "" },
        { "UniqueName", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations"

	payload := strings.NewReader("Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Services/:ChatServiceSid/Conversations HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 123

Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=")
  .asString();

const data = 'Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('MessagingServiceSid', '');
encodedParams.set('State', '');
encodedParams.set('Timers.Closed', '');
encodedParams.set('Timers.Inactive', '');
encodedParams.set('UniqueName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    FriendlyName: '',
    MessagingServiceSid: '',
    State: '',
    'Timers.Closed': '',
    'Timers.Inactive': '',
    UniqueName: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    FriendlyName: '',
    MessagingServiceSid: '',
    State: '',
    'Timers.Closed': '',
    'Timers.Inactive': '',
    UniqueName: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  Attributes: '',
  DateCreated: '',
  DateUpdated: '',
  FriendlyName: '',
  MessagingServiceSid: '',
  State: '',
  'Timers.Closed': '',
  'Timers.Inactive': '',
  UniqueName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    FriendlyName: '',
    MessagingServiceSid: '',
    State: '',
    'Timers.Closed': '',
    'Timers.Inactive': '',
    UniqueName: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Attributes: '',
  DateCreated: '',
  DateUpdated: '',
  FriendlyName: '',
  MessagingServiceSid: '',
  State: '',
  'Timers.Closed': '',
  'Timers.Inactive': '',
  UniqueName: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('MessagingServiceSid', '');
encodedParams.set('State', '');
encodedParams.set('Timers.Closed', '');
encodedParams.set('Timers.Inactive', '');
encodedParams.set('UniqueName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('MessagingServiceSid', '');
encodedParams.set('State', '');
encodedParams.set('Timers.Closed', '');
encodedParams.set('Timers.Inactive', '');
encodedParams.set('UniqueName', '');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateCreated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateUpdated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MessagingServiceSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&State=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Timers.Closed=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Timers.Inactive=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UniqueName=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations', [
  'form_params' => [
    'Attributes' => '',
    'DateCreated' => '',
    'DateUpdated' => '',
    'FriendlyName' => '',
    'MessagingServiceSid' => '',
    'State' => '',
    'Timers.Closed' => '',
    'Timers.Inactive' => '',
    'UniqueName' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Attributes' => '',
  'DateCreated' => '',
  'DateUpdated' => '',
  'FriendlyName' => '',
  'MessagingServiceSid' => '',
  'State' => '',
  'Timers.Closed' => '',
  'Timers.Inactive' => '',
  'UniqueName' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Attributes' => '',
  'DateCreated' => '',
  'DateUpdated' => '',
  'FriendlyName' => '',
  'MessagingServiceSid' => '',
  'State' => '',
  'Timers.Closed' => '',
  'Timers.Inactive' => '',
  'UniqueName' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ChatServiceSid/Conversations", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations"

payload = {
    "Attributes": "",
    "DateCreated": "",
    "DateUpdated": "",
    "FriendlyName": "",
    "MessagingServiceSid": "",
    "State": "",
    "Timers.Closed": "",
    "Timers.Inactive": "",
    "UniqueName": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations"

payload <- "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName="

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

require 'faraday'

data = {
  :Attributes => "",
  :DateCreated => "",
  :DateUpdated => "",
  :FriendlyName => "",
  :MessagingServiceSid => "",
  :State => "",
  :Timers.Closed => "",
  :Timers.Inactive => "",
  :UniqueName => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ChatServiceSid/Conversations') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations";

    let payload = json!({
        "Attributes": "",
        "DateCreated": "",
        "DateUpdated": "",
        "FriendlyName": "",
        "MessagingServiceSid": "",
        "State": "",
        "Timers.Closed": "",
        "Timers.Inactive": "",
        "UniqueName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data DateCreated= \
  --data DateUpdated= \
  --data FriendlyName= \
  --data MessagingServiceSid= \
  --data State= \
  --data Timers.Closed= \
  --data Timers.Inactive= \
  --data UniqueName=

http --form POST {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  DateCreated='' \
  DateUpdated='' \
  FriendlyName='' \
  MessagingServiceSid='' \
  State='' \
  Timers.Closed='' \
  Timers.Inactive='' \
  UniqueName=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&DateCreated=".data(using: String.Encoding.utf8)!)
postData.append("&DateUpdated=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&MessagingServiceSid=".data(using: String.Encoding.utf8)!)
postData.append("&State=".data(using: String.Encoding.utf8)!)
postData.append("&Timers.Closed=".data(using: String.Encoding.utf8)!)
postData.append("&Timers.Inactive=".data(using: String.Encoding.utf8)!)
postData.append("&UniqueName=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateServiceConversationMessage

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages

QUERY PARAMS

ChatServiceSid

ConversationSid

BODY formUrlEncoded

Attributes

Author

Body

ContentSid

ContentVariables

DateCreated

DateUpdated

MediaSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages" {:form-params {:Attributes ""
                                                                                                                              :Author ""
                                                                                                                              :Body ""
                                                                                                                              :ContentSid ""
                                                                                                                              :ContentVariables ""
                                                                                                                              :DateCreated ""
                                                                                                                              :DateUpdated ""
                                                                                                                              :MediaSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "Author", "" },
        { "Body", "" },
        { "ContentSid", "" },
        { "ContentVariables", "" },
        { "DateCreated", "" },
        { "DateUpdated", "" },
        { "MediaSid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages"

	payload := strings.NewReader("Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 91

Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=")
  .asString();

const data = 'Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('Author', '');
encodedParams.set('Body', '');
encodedParams.set('ContentSid', '');
encodedParams.set('ContentVariables', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('MediaSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    Attributes: '',
    Author: '',
    Body: '',
    ContentSid: '',
    ContentVariables: '',
    DateCreated: '',
    DateUpdated: '',
    MediaSid: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    Author: '',
    Body: '',
    ContentSid: '',
    ContentVariables: '',
    DateCreated: '',
    DateUpdated: '',
    MediaSid: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  Attributes: '',
  Author: '',
  Body: '',
  ContentSid: '',
  ContentVariables: '',
  DateCreated: '',
  DateUpdated: '',
  MediaSid: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    Attributes: '',
    Author: '',
    Body: '',
    ContentSid: '',
    ContentVariables: '',
    DateCreated: '',
    DateUpdated: '',
    MediaSid: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Attributes: '',
  Author: '',
  Body: '',
  ContentSid: '',
  ContentVariables: '',
  DateCreated: '',
  DateUpdated: '',
  MediaSid: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('Author', '');
encodedParams.set('Body', '');
encodedParams.set('ContentSid', '');
encodedParams.set('ContentVariables', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('MediaSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('Author', '');
encodedParams.set('Body', '');
encodedParams.set('ContentSid', '');
encodedParams.set('ContentVariables', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('MediaSid', '');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Author=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Body=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ContentSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ContentVariables=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateCreated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateUpdated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MediaSid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages', [
  'form_params' => [
    'Attributes' => '',
    'Author' => '',
    'Body' => '',
    'ContentSid' => '',
    'ContentVariables' => '',
    'DateCreated' => '',
    'DateUpdated' => '',
    'MediaSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Attributes' => '',
  'Author' => '',
  'Body' => '',
  'ContentSid' => '',
  'ContentVariables' => '',
  'DateCreated' => '',
  'DateUpdated' => '',
  'MediaSid' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Attributes' => '',
  'Author' => '',
  'Body' => '',
  'ContentSid' => '',
  'ContentVariables' => '',
  'DateCreated' => '',
  'DateUpdated' => '',
  'MediaSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages"

payload = {
    "Attributes": "",
    "Author": "",
    "Body": "",
    "ContentSid": "",
    "ContentVariables": "",
    "DateCreated": "",
    "DateUpdated": "",
    "MediaSid": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages"

payload <- "Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid="

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

require 'faraday'

data = {
  :Attributes => "",
  :Author => "",
  :Body => "",
  :ContentSid => "",
  :ContentVariables => "",
  :DateCreated => "",
  :DateUpdated => "",
  :MediaSid => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages";

    let payload = json!({
        "Attributes": "",
        "Author": "",
        "Body": "",
        "ContentSid": "",
        "ContentVariables": "",
        "DateCreated": "",
        "DateUpdated": "",
        "MediaSid": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data Author= \
  --data Body= \
  --data ContentSid= \
  --data ContentVariables= \
  --data DateCreated= \
  --data DateUpdated= \
  --data MediaSid=

http --form POST {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  Author='' \
  Body='' \
  ContentSid='' \
  ContentVariables='' \
  DateCreated='' \
  DateUpdated='' \
  MediaSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&Author=&Body=&ContentSid=&ContentVariables=&DateCreated=&DateUpdated=&MediaSid=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&Author=".data(using: String.Encoding.utf8)!)
postData.append("&Body=".data(using: String.Encoding.utf8)!)
postData.append("&ContentSid=".data(using: String.Encoding.utf8)!)
postData.append("&ContentVariables=".data(using: String.Encoding.utf8)!)
postData.append("&DateCreated=".data(using: String.Encoding.utf8)!)
postData.append("&DateUpdated=".data(using: String.Encoding.utf8)!)
postData.append("&MediaSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateServiceConversationParticipant

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants

QUERY PARAMS

ChatServiceSid

ConversationSid

BODY formUrlEncoded

Attributes

DateCreated

DateUpdated

Identity

MessagingBinding.Address

MessagingBinding.ProjectedAddress

MessagingBinding.ProxyAddress

RoleSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants" {:form-params {:Attributes ""
                                                                                                                                  :DateCreated ""
                                                                                                                                  :DateUpdated ""
                                                                                                                                  :Identity ""
                                                                                                                                  :MessagingBinding.Address ""
                                                                                                                                  :MessagingBinding.ProjectedAddress ""
                                                                                                                                  :MessagingBinding.ProxyAddress ""
                                                                                                                                  :RoleSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "DateCreated", "" },
        { "DateUpdated", "" },
        { "Identity", "" },
        { "MessagingBinding.Address", "" },
        { "MessagingBinding.ProjectedAddress", "" },
        { "MessagingBinding.ProxyAddress", "" },
        { "RoleSid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants"

	payload := strings.NewReader("Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 148

Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=")
  .asString();

const data = 'Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('Identity', '');
encodedParams.set('MessagingBinding.Address', '');
encodedParams.set('MessagingBinding.ProjectedAddress', '');
encodedParams.set('MessagingBinding.ProxyAddress', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    Identity: '',
    'MessagingBinding.Address': '',
    'MessagingBinding.ProjectedAddress': '',
    'MessagingBinding.ProxyAddress': '',
    RoleSid: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    Identity: '',
    'MessagingBinding.Address': '',
    'MessagingBinding.ProjectedAddress': '',
    'MessagingBinding.ProxyAddress': '',
    RoleSid: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  Attributes: '',
  DateCreated: '',
  DateUpdated: '',
  Identity: '',
  'MessagingBinding.Address': '',
  'MessagingBinding.ProjectedAddress': '',
  'MessagingBinding.ProxyAddress': '',
  RoleSid: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    Identity: '',
    'MessagingBinding.Address': '',
    'MessagingBinding.ProjectedAddress': '',
    'MessagingBinding.ProxyAddress': '',
    RoleSid: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Attributes: '',
  DateCreated: '',
  DateUpdated: '',
  Identity: '',
  'MessagingBinding.Address': '',
  'MessagingBinding.ProjectedAddress': '',
  'MessagingBinding.ProxyAddress': '',
  RoleSid: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('Identity', '');
encodedParams.set('MessagingBinding.Address', '');
encodedParams.set('MessagingBinding.ProjectedAddress', '');
encodedParams.set('MessagingBinding.ProxyAddress', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('Identity', '');
encodedParams.set('MessagingBinding.Address', '');
encodedParams.set('MessagingBinding.ProjectedAddress', '');
encodedParams.set('MessagingBinding.ProxyAddress', '');
encodedParams.set('RoleSid', '');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateCreated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateUpdated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Identity=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MessagingBinding.Address=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MessagingBinding.ProjectedAddress=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MessagingBinding.ProxyAddress=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&RoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants', [
  'form_params' => [
    'Attributes' => '',
    'DateCreated' => '',
    'DateUpdated' => '',
    'Identity' => '',
    'MessagingBinding.Address' => '',
    'MessagingBinding.ProjectedAddress' => '',
    'MessagingBinding.ProxyAddress' => '',
    'RoleSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Attributes' => '',
  'DateCreated' => '',
  'DateUpdated' => '',
  'Identity' => '',
  'MessagingBinding.Address' => '',
  'MessagingBinding.ProjectedAddress' => '',
  'MessagingBinding.ProxyAddress' => '',
  'RoleSid' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Attributes' => '',
  'DateCreated' => '',
  'DateUpdated' => '',
  'Identity' => '',
  'MessagingBinding.Address' => '',
  'MessagingBinding.ProjectedAddress' => '',
  'MessagingBinding.ProxyAddress' => '',
  'RoleSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants"

payload = {
    "Attributes": "",
    "DateCreated": "",
    "DateUpdated": "",
    "Identity": "",
    "MessagingBinding.Address": "",
    "MessagingBinding.ProjectedAddress": "",
    "MessagingBinding.ProxyAddress": "",
    "RoleSid": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants"

payload <- "Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid="

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

require 'faraday'

data = {
  :Attributes => "",
  :DateCreated => "",
  :DateUpdated => "",
  :Identity => "",
  :MessagingBinding.Address => "",
  :MessagingBinding.ProjectedAddress => "",
  :MessagingBinding.ProxyAddress => "",
  :RoleSid => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants";

    let payload = json!({
        "Attributes": "",
        "DateCreated": "",
        "DateUpdated": "",
        "Identity": "",
        "MessagingBinding.Address": "",
        "MessagingBinding.ProjectedAddress": "",
        "MessagingBinding.ProxyAddress": "",
        "RoleSid": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data DateCreated= \
  --data DateUpdated= \
  --data Identity= \
  --data MessagingBinding.Address= \
  --data MessagingBinding.ProjectedAddress= \
  --data MessagingBinding.ProxyAddress= \
  --data RoleSid=

http --form POST {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  DateCreated='' \
  DateUpdated='' \
  Identity='' \
  MessagingBinding.Address='' \
  MessagingBinding.ProjectedAddress='' \
  MessagingBinding.ProxyAddress='' \
  RoleSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&DateCreated=&DateUpdated=&Identity=&MessagingBinding.Address=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&DateCreated=".data(using: String.Encoding.utf8)!)
postData.append("&DateUpdated=".data(using: String.Encoding.utf8)!)
postData.append("&Identity=".data(using: String.Encoding.utf8)!)
postData.append("&MessagingBinding.Address=".data(using: String.Encoding.utf8)!)
postData.append("&MessagingBinding.ProjectedAddress=".data(using: String.Encoding.utf8)!)
postData.append("&MessagingBinding.ProxyAddress=".data(using: String.Encoding.utf8)!)
postData.append("&RoleSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateServiceConversationScopedWebhook

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks

QUERY PARAMS

ChatServiceSid

ConversationSid

BODY formUrlEncoded

Configuration.Filters

Configuration.FlowSid

Configuration.Method

Configuration.ReplayAfter

Configuration.Triggers

Configuration.Url

Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks" {:form-params {:Configuration.Filters ""
                                                                                                                              :Configuration.FlowSid ""
                                                                                                                              :Configuration.Method ""
                                                                                                                              :Configuration.ReplayAfter ""
                                                                                                                              :Configuration.Triggers ""
                                                                                                                              :Configuration.Url ""
                                                                                                                              :Target ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Configuration.Filters", "" },
        { "Configuration.FlowSid", "" },
        { "Configuration.Method", "" },
        { "Configuration.ReplayAfter", "" },
        { "Configuration.Triggers", "" },
        { "Configuration.Url", "" },
        { "Target", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks"

	payload := strings.NewReader("Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 145

Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=")
  .asString();

const data = 'Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Configuration.Filters', '');
encodedParams.set('Configuration.FlowSid', '');
encodedParams.set('Configuration.Method', '');
encodedParams.set('Configuration.ReplayAfter', '');
encodedParams.set('Configuration.Triggers', '');
encodedParams.set('Configuration.Url', '');
encodedParams.set('Target', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    'Configuration.Filters': '',
    'Configuration.FlowSid': '',
    'Configuration.Method': '',
    'Configuration.ReplayAfter': '',
    'Configuration.Triggers': '',
    'Configuration.Url': '',
    Target: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    'Configuration.Filters': '',
    'Configuration.FlowSid': '',
    'Configuration.Method': '',
    'Configuration.ReplayAfter': '',
    'Configuration.Triggers': '',
    'Configuration.Url': '',
    Target: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  'Configuration.Filters': '',
  'Configuration.FlowSid': '',
  'Configuration.Method': '',
  'Configuration.ReplayAfter': '',
  'Configuration.Triggers': '',
  'Configuration.Url': '',
  Target: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    'Configuration.Filters': '',
    'Configuration.FlowSid': '',
    'Configuration.Method': '',
    'Configuration.ReplayAfter': '',
    'Configuration.Triggers': '',
    'Configuration.Url': '',
    Target: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  'Configuration.Filters': '',
  'Configuration.FlowSid': '',
  'Configuration.Method': '',
  'Configuration.ReplayAfter': '',
  'Configuration.Triggers': '',
  'Configuration.Url': '',
  Target: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Configuration.Filters', '');
encodedParams.set('Configuration.FlowSid', '');
encodedParams.set('Configuration.Method', '');
encodedParams.set('Configuration.ReplayAfter', '');
encodedParams.set('Configuration.Triggers', '');
encodedParams.set('Configuration.Url', '');
encodedParams.set('Target', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Configuration.Filters', '');
encodedParams.set('Configuration.FlowSid', '');
encodedParams.set('Configuration.Method', '');
encodedParams.set('Configuration.ReplayAfter', '');
encodedParams.set('Configuration.Triggers', '');
encodedParams.set('Configuration.Url', '');
encodedParams.set('Target', '');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Configuration.Filters=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Configuration.FlowSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Configuration.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Configuration.ReplayAfter=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Configuration.Triggers=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Configuration.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Target=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks', [
  'form_params' => [
    'Configuration.Filters' => '',
    'Configuration.FlowSid' => '',
    'Configuration.Method' => '',
    'Configuration.ReplayAfter' => '',
    'Configuration.Triggers' => '',
    'Configuration.Url' => '',
    'Target' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Configuration.Filters' => '',
  'Configuration.FlowSid' => '',
  'Configuration.Method' => '',
  'Configuration.ReplayAfter' => '',
  'Configuration.Triggers' => '',
  'Configuration.Url' => '',
  'Target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Configuration.Filters' => '',
  'Configuration.FlowSid' => '',
  'Configuration.Method' => '',
  'Configuration.ReplayAfter' => '',
  'Configuration.Triggers' => '',
  'Configuration.Url' => '',
  'Target' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks"

payload = {
    "Configuration.Filters": "",
    "Configuration.FlowSid": "",
    "Configuration.Method": "",
    "Configuration.ReplayAfter": "",
    "Configuration.Triggers": "",
    "Configuration.Url": "",
    "Target": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks"

payload <- "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target="

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

require 'faraday'

data = {
  :Configuration.Filters => "",
  :Configuration.FlowSid => "",
  :Configuration.Method => "",
  :Configuration.ReplayAfter => "",
  :Configuration.Triggers => "",
  :Configuration.Url => "",
  :Target => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks";

    let payload = json!({
        "Configuration.Filters": "",
        "Configuration.FlowSid": "",
        "Configuration.Method": "",
        "Configuration.ReplayAfter": "",
        "Configuration.Triggers": "",
        "Configuration.Url": "",
        "Target": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Configuration.Filters= \
  --data Configuration.FlowSid= \
  --data Configuration.Method= \
  --data Configuration.ReplayAfter= \
  --data Configuration.Triggers= \
  --data Configuration.Url= \
  --data Target=

http --form POST {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks \
  content-type:application/x-www-form-urlencoded \
  Configuration.Filters='' \
  Configuration.FlowSid='' \
  Configuration.Method='' \
  Configuration.ReplayAfter='' \
  Configuration.Triggers='' \
  Configuration.Url='' \
  Target=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.ReplayAfter=&Configuration.Triggers=&Configuration.Url=&Target=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Configuration.Filters=".data(using: String.Encoding.utf8)!)
postData.append("&Configuration.FlowSid=".data(using: String.Encoding.utf8)!)
postData.append("&Configuration.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Configuration.ReplayAfter=".data(using: String.Encoding.utf8)!)
postData.append("&Configuration.Triggers=".data(using: String.Encoding.utf8)!)
postData.append("&Configuration.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Target=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateServiceRole

{{baseUrl}}/v1/Services/:ChatServiceSid/Roles

QUERY PARAMS

ChatServiceSid

BODY formUrlEncoded

FriendlyName

Permission

Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "FriendlyName=&Permission=&Type=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles" {:form-params {:FriendlyName ""
                                                                                            :Permission ""
                                                                                            :Type ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "FriendlyName=&Permission=&Type="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "FriendlyName", "" },
        { "Permission", "" },
        { "Type", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "FriendlyName=&Permission=&Type=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles"

	payload := strings.NewReader("FriendlyName=&Permission=&Type=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Services/:ChatServiceSid/Roles HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 31

FriendlyName=&Permission=&Type=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("FriendlyName=&Permission=&Type=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("FriendlyName=&Permission=&Type="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "FriendlyName=&Permission=&Type=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("FriendlyName=&Permission=&Type=")
  .asString();

const data = 'FriendlyName=&Permission=&Type=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('FriendlyName', '');
encodedParams.set('Permission', '');
encodedParams.set('Type', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({FriendlyName: '', Permission: '', Type: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    FriendlyName: '',
    Permission: '',
    Type: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "FriendlyName=&Permission=&Type=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Roles',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({FriendlyName: '', Permission: '', Type: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {FriendlyName: '', Permission: '', Type: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  FriendlyName: '',
  Permission: '',
  Type: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('FriendlyName', '');
encodedParams.set('Permission', '');
encodedParams.set('Type', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('FriendlyName', '');
encodedParams.set('Permission', '');
encodedParams.set('Type', '');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Permission=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Type=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Roles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "FriendlyName=&Permission=&Type=" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "FriendlyName=&Permission=&Type=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles', [
  'form_params' => [
    'FriendlyName' => '',
    'Permission' => '',
    'Type' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Roles');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'FriendlyName' => '',
  'Permission' => '',
  'Type' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'FriendlyName' => '',
  'Permission' => '',
  'Type' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Roles');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'FriendlyName=&Permission=&Type='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'FriendlyName=&Permission=&Type='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "FriendlyName=&Permission=&Type="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ChatServiceSid/Roles", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles"

payload = {
    "FriendlyName": "",
    "Permission": "",
    "Type": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles"

payload <- "FriendlyName=&Permission=&Type="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "FriendlyName=&Permission=&Type="

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

require 'faraday'

data = {
  :FriendlyName => "",
  :Permission => "",
  :Type => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ChatServiceSid/Roles') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles";

    let payload = json!({
        "FriendlyName": "",
        "Permission": "",
        "Type": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Roles \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data FriendlyName= \
  --data Permission= \
  --data Type=

http --form POST {{baseUrl}}/v1/Services/:ChatServiceSid/Roles \
  content-type:application/x-www-form-urlencoded \
  FriendlyName='' \
  Permission='' \
  Type=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'FriendlyName=&Permission=&Type=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Roles

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&Permission=".data(using: String.Encoding.utf8)!)
postData.append("&Type=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateServiceUser

{{baseUrl}}/v1/Services/:ChatServiceSid/Users

QUERY PARAMS

ChatServiceSid

BODY formUrlEncoded

Attributes

FriendlyName

Identity

RoleSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Users");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Attributes=&FriendlyName=&Identity=&RoleSid=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ChatServiceSid/Users" {:form-params {:Attributes ""
                                                                                            :FriendlyName ""
                                                                                            :Identity ""
                                                                                            :RoleSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&FriendlyName=&Identity=&RoleSid="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Users"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "FriendlyName", "" },
        { "Identity", "" },
        { "RoleSid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Users");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&FriendlyName=&Identity=&RoleSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Users"

	payload := strings.NewReader("Attributes=&FriendlyName=&Identity=&RoleSid=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Services/:ChatServiceSid/Users HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 44

Attributes=&FriendlyName=&Identity=&RoleSid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ChatServiceSid/Users")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Attributes=&FriendlyName=&Identity=&RoleSid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Users"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&FriendlyName=&Identity=&RoleSid="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Attributes=&FriendlyName=&Identity=&RoleSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Users")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/:ChatServiceSid/Users")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&FriendlyName=&Identity=&RoleSid=")
  .asString();

const data = 'Attributes=&FriendlyName=&Identity=&RoleSid=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Identity', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Users';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Attributes: '', FriendlyName: '', Identity: '', RoleSid: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    FriendlyName: '',
    Identity: '',
    RoleSid: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Attributes=&FriendlyName=&Identity=&RoleSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Users")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Users',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({Attributes: '', FriendlyName: '', Identity: '', RoleSid: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Attributes: '', FriendlyName: '', Identity: '', RoleSid: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Attributes: '',
  FriendlyName: '',
  Identity: '',
  RoleSid: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Identity', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Identity', '');
encodedParams.set('RoleSid', '');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Users';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Identity=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&RoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Users"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Users" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&FriendlyName=&Identity=&RoleSid=" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Users",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Attributes=&FriendlyName=&Identity=&RoleSid=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users', [
  'form_params' => [
    'Attributes' => '',
    'FriendlyName' => '',
    'Identity' => '',
    'RoleSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Users');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Attributes' => '',
  'FriendlyName' => '',
  'Identity' => '',
  'RoleSid' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Attributes' => '',
  'FriendlyName' => '',
  'Identity' => '',
  'RoleSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Users');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Users' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&FriendlyName=&Identity=&RoleSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Users' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&FriendlyName=&Identity=&RoleSid='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Attributes=&FriendlyName=&Identity=&RoleSid="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ChatServiceSid/Users", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users"

payload = {
    "Attributes": "",
    "FriendlyName": "",
    "Identity": "",
    "RoleSid": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Users"

payload <- "Attributes=&FriendlyName=&Identity=&RoleSid="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Users")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Attributes=&FriendlyName=&Identity=&RoleSid="

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

require 'faraday'

data = {
  :Attributes => "",
  :FriendlyName => "",
  :Identity => "",
  :RoleSid => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ChatServiceSid/Users') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users";

    let payload = json!({
        "Attributes": "",
        "FriendlyName": "",
        "Identity": "",
        "RoleSid": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Users \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data FriendlyName= \
  --data Identity= \
  --data RoleSid=

http --form POST {{baseUrl}}/v1/Services/:ChatServiceSid/Users \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  FriendlyName='' \
  Identity='' \
  RoleSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&FriendlyName=&Identity=&RoleSid=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Users

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&Identity=".data(using: String.Encoding.utf8)!)
postData.append("&RoleSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Users")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateUser

{{baseUrl}}/v1/Users

BODY formUrlEncoded

Attributes

FriendlyName

Identity

RoleSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Users");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Attributes=&FriendlyName=&Identity=&RoleSid=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Users" {:form-params {:Attributes ""
                                                                   :FriendlyName ""
                                                                   :Identity ""
                                                                   :RoleSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Users"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&FriendlyName=&Identity=&RoleSid="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Users"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "FriendlyName", "" },
        { "Identity", "" },
        { "RoleSid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Users");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&FriendlyName=&Identity=&RoleSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Users"

	payload := strings.NewReader("Attributes=&FriendlyName=&Identity=&RoleSid=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Users HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 44

Attributes=&FriendlyName=&Identity=&RoleSid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Users")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Attributes=&FriendlyName=&Identity=&RoleSid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Users"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&FriendlyName=&Identity=&RoleSid="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Attributes=&FriendlyName=&Identity=&RoleSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Users")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Users")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&FriendlyName=&Identity=&RoleSid=")
  .asString();

const data = 'Attributes=&FriendlyName=&Identity=&RoleSid=';

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

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

xhr.open('POST', '{{baseUrl}}/v1/Users');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Identity', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Users',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Users';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Attributes: '', FriendlyName: '', Identity: '', RoleSid: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Users',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    FriendlyName: '',
    Identity: '',
    RoleSid: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Attributes=&FriendlyName=&Identity=&RoleSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Users")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Users',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({Attributes: '', FriendlyName: '', Identity: '', RoleSid: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Users',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Attributes: '', FriendlyName: '', Identity: '', RoleSid: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Users');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Attributes: '',
  FriendlyName: '',
  Identity: '',
  RoleSid: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Identity', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Users',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Identity', '');
encodedParams.set('RoleSid', '');

const url = '{{baseUrl}}/v1/Users';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Identity=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&RoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Users"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Users" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&FriendlyName=&Identity=&RoleSid=" in

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

 "{{baseUrl}}/v1/Users",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Attributes=&FriendlyName=&Identity=&RoleSid=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Users', [
  'form_params' => [
    'Attributes' => '',
    'FriendlyName' => '',
    'Identity' => '',
    'RoleSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Users');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Attributes' => '',
  'FriendlyName' => '',
  'Identity' => '',
  'RoleSid' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Attributes' => '',
  'FriendlyName' => '',
  'Identity' => '',
  'RoleSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Users');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Users' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&FriendlyName=&Identity=&RoleSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Users' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&FriendlyName=&Identity=&RoleSid='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Attributes=&FriendlyName=&Identity=&RoleSid="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Users", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Users"

payload = {
    "Attributes": "",
    "FriendlyName": "",
    "Identity": "",
    "RoleSid": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Users"

payload <- "Attributes=&FriendlyName=&Identity=&RoleSid="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Users")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Attributes=&FriendlyName=&Identity=&RoleSid="

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

require 'faraday'

data = {
  :Attributes => "",
  :FriendlyName => "",
  :Identity => "",
  :RoleSid => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Users') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Users";

    let payload = json!({
        "Attributes": "",
        "FriendlyName": "",
        "Identity": "",
        "RoleSid": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Users \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data FriendlyName= \
  --data Identity= \
  --data RoleSid=

http --form POST {{baseUrl}}/v1/Users \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  FriendlyName='' \
  Identity='' \
  RoleSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&FriendlyName=&Identity=&RoleSid=' \
  --output-document \
  - {{baseUrl}}/v1/Users

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&Identity=".data(using: String.Encoding.utf8)!)
postData.append("&RoleSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Users")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteConfigurationAddress

{{baseUrl}}/v1/Configuration/Addresses/:Sid

QUERY PARAMS

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Configuration/Addresses/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Configuration/Addresses/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Configuration/Addresses/:Sid"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v1/Configuration/Addresses/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Configuration/Addresses/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Configuration/Addresses/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v1/Configuration/Addresses/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Configuration/Addresses/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Configuration/Addresses/:Sid"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Configuration/Addresses/:Sid")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Configuration/Addresses/:Sid")
  .asString();

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('DELETE', '{{baseUrl}}/v1/Configuration/Addresses/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Configuration/Addresses/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Configuration/Addresses/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Configuration/Addresses/:Sid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Configuration/Addresses/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Configuration/Addresses/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Configuration/Addresses/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/Configuration/Addresses/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Configuration/Addresses/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Configuration/Addresses/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Configuration/Addresses/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Configuration/Addresses/:Sid" in

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

 "{{baseUrl}}/v1/Configuration/Addresses/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v1/Configuration/Addresses/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Configuration/Addresses/:Sid');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Configuration/Addresses/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Configuration/Addresses/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Configuration/Addresses/:Sid' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/Configuration/Addresses/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Configuration/Addresses/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Configuration/Addresses/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Configuration/Addresses/:Sid")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v1/Configuration/Addresses/:Sid') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Configuration/Addresses/:Sid";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Configuration/Addresses/:Sid

http DELETE {{baseUrl}}/v1/Configuration/Addresses/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Configuration/Addresses/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Configuration/Addresses/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteConversation

{{baseUrl}}/v1/Conversations/:Sid

QUERY PARAMS

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Conversations/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Conversations/:Sid"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Conversations/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v1/Conversations/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Conversations/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations/:Sid"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:Sid")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Conversations/:Sid")
  .asString();

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('DELETE', '{{baseUrl}}/v1/Conversations/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v1/Conversations/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations/:Sid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/v1/Conversations/:Sid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/Conversations/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/v1/Conversations/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Conversations/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations/:Sid" in

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

 "{{baseUrl}}/v1/Conversations/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v1/Conversations/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations/:Sid');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Conversations/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations/:Sid' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/Conversations/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations/:Sid")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v1/Conversations/:Sid') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations/:Sid";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Conversations/:Sid

http DELETE {{baseUrl}}/v1/Conversations/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Conversations/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteConversationMessage

{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid

QUERY PARAMS

ConversationSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v1/Conversations/:ConversationSid/Messages/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid")
  .asString();

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('DELETE', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations/:ConversationSid/Messages/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid" in

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

 "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/Conversations/:ConversationSid/Messages/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v1/Conversations/:ConversationSid/Messages/:Sid') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid

http DELETE {{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteConversationParticipant

{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid

QUERY PARAMS

ConversationSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v1/Conversations/:ConversationSid/Participants/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid")
  .asString();

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('DELETE', '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations/:ConversationSid/Participants/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid" in

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

 "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/Conversations/:ConversationSid/Participants/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v1/Conversations/:ConversationSid/Participants/:Sid') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid

http DELETE {{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteConversationScopedWebhook

{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid

QUERY PARAMS

ConversationSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v1/Conversations/:ConversationSid/Webhooks/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid")
  .asString();

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('DELETE', '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations/:ConversationSid/Webhooks/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid" in

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

 "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/Conversations/:ConversationSid/Webhooks/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v1/Conversations/:ConversationSid/Webhooks/:Sid') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid

http DELETE {{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteCredential

{{baseUrl}}/v1/Credentials/:Sid

QUERY PARAMS

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Credentials/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Credentials/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Credentials/:Sid"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v1/Credentials/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Credentials/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Credentials/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v1/Credentials/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Credentials/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Credentials/:Sid"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Credentials/:Sid")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Credentials/:Sid")
  .asString();

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('DELETE', '{{baseUrl}}/v1/Credentials/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v1/Credentials/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Credentials/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Credentials/:Sid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Credentials/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Credentials/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/v1/Credentials/:Sid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/Credentials/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/v1/Credentials/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Credentials/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Credentials/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Credentials/:Sid" in

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

 "{{baseUrl}}/v1/Credentials/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v1/Credentials/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Credentials/:Sid');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Credentials/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Credentials/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Credentials/:Sid' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/Credentials/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Credentials/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Credentials/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Credentials/:Sid")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v1/Credentials/:Sid') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Credentials/:Sid";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Credentials/:Sid

http DELETE {{baseUrl}}/v1/Credentials/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Credentials/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Credentials/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteRole

{{baseUrl}}/v1/Roles/:Sid

QUERY PARAMS

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Roles/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Roles/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Roles/:Sid"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v1/Roles/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Roles/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Roles/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v1/Roles/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Roles/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Roles/:Sid"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Roles/:Sid")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Roles/:Sid")
  .asString();

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('DELETE', '{{baseUrl}}/v1/Roles/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v1/Roles/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Roles/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Roles/:Sid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Roles/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Roles/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/v1/Roles/:Sid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/Roles/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/v1/Roles/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Roles/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Roles/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Roles/:Sid" in

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

 "{{baseUrl}}/v1/Roles/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v1/Roles/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Roles/:Sid');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Roles/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Roles/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Roles/:Sid' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/Roles/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Roles/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Roles/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Roles/:Sid")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v1/Roles/:Sid') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Roles/:Sid";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Roles/:Sid

http DELETE {{baseUrl}}/v1/Roles/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Roles/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Roles/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteService

{{baseUrl}}/v1/Services/:Sid

QUERY PARAMS

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:Sid"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v1/Services/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Services/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:Sid"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:Sid")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:Sid")
  .asString();

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('DELETE', '{{baseUrl}}/v1/Services/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v1/Services/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:Sid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/v1/Services/:Sid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/Services/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/v1/Services/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:Sid" in

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

 "{{baseUrl}}/v1/Services/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v1/Services/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:Sid');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:Sid' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/Services/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:Sid")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v1/Services/:Sid') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:Sid";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Services/:Sid

http DELETE {{baseUrl}}/v1/Services/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteServiceBinding

{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid

QUERY PARAMS

ChatServiceSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v1/Services/:ChatServiceSid/Bindings/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid")
  .asString();

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('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Bindings/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/Services/:ChatServiceSid/Bindings/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v1/Services/:ChatServiceSid/Bindings/:Sid') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid

http DELETE {{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteServiceConversation

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid

QUERY PARAMS

ChatServiceSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v1/Services/:ChatServiceSid/Conversations/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid")
  .asString();

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('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/Services/:ChatServiceSid/Conversations/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v1/Services/:ChatServiceSid/Conversations/:Sid') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid

http DELETE {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteServiceConversationMessage

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid

QUERY PARAMS

ChatServiceSid

ConversationSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")
  .asString();

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('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid

http DELETE {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteServiceConversationParticipant

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid

QUERY PARAMS

ChatServiceSid

ConversationSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")
  .asString();

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('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid

http DELETE {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteServiceConversationScopedWebhook

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid

QUERY PARAMS

ChatServiceSid

ConversationSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")
  .asString();

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('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid

http DELETE {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteServiceRole

{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid

QUERY PARAMS

ChatServiceSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v1/Services/:ChatServiceSid/Roles/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid")
  .asString();

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('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Roles/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/Services/:ChatServiceSid/Roles/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v1/Services/:ChatServiceSid/Roles/:Sid') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid

http DELETE {{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteServiceUser

{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid

QUERY PARAMS

ChatServiceSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v1/Services/:ChatServiceSid/Users/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid")
  .asString();

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('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Users/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/Services/:ChatServiceSid/Users/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v1/Services/:ChatServiceSid/Users/:Sid') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid

http DELETE {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteServiceUserConversation

{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid

QUERY PARAMS

ChatServiceSid

UserSid

ConversationSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")
  .asString();

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('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid

http DELETE {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteUser

{{baseUrl}}/v1/Users/:Sid

QUERY PARAMS

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Users/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Users/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Users/:Sid"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v1/Users/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Users/:Sid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Users/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v1/Users/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Users/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Users/:Sid"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Users/:Sid")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Users/:Sid")
  .asString();

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('DELETE', '{{baseUrl}}/v1/Users/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v1/Users/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Users/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Users/:Sid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Users/:Sid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Users/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/v1/Users/:Sid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/Users/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/v1/Users/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Users/:Sid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Users/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Users/:Sid" in

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

 "{{baseUrl}}/v1/Users/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v1/Users/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Users/:Sid');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Users/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Users/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Users/:Sid' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/Users/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Users/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Users/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Users/:Sid")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v1/Users/:Sid') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Users/:Sid";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Users/:Sid

http DELETE {{baseUrl}}/v1/Users/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Users/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Users/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteUserConversation

{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid

QUERY PARAMS

UserSid

ConversationSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid")

require "http/client"

url = "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v1/Users/:UserSid/Conversations/:ConversationSid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid")
  .asString();

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('DELETE', '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Users/:UserSid/Conversations/:ConversationSid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid" in

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

 "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/Users/:UserSid/Conversations/:ConversationSid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v1/Users/:UserSid/Conversations/:ConversationSid') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid

http DELETE {{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchConfiguration

{{baseUrl}}/v1/Configuration

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Configuration");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Configuration")

require "http/client"

url = "{{baseUrl}}/v1/Configuration"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Configuration"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Configuration");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Configuration"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Configuration HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Configuration")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Configuration"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Configuration")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Configuration")
  .asString();

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', '{{baseUrl}}/v1/Configuration');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Configuration'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Configuration';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Configuration',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Configuration")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Configuration',
  headers: {}
};

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

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/Configuration'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Configuration');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/Configuration'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Configuration';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Configuration"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Configuration" in

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

 "{{baseUrl}}/v1/Configuration",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Configuration');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Configuration');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Configuration');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Configuration' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Configuration' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Configuration")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Configuration"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Configuration"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Configuration")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Configuration') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Configuration";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Configuration

http GET {{baseUrl}}/v1/Configuration

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Configuration

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Configuration")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchConfigurationAddress

{{baseUrl}}/v1/Configuration/Addresses/:Sid

QUERY PARAMS

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Configuration/Addresses/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Configuration/Addresses/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Configuration/Addresses/:Sid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Configuration/Addresses/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Configuration/Addresses/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Configuration/Addresses/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Configuration/Addresses/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Configuration/Addresses/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Configuration/Addresses/:Sid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Configuration/Addresses/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Configuration/Addresses/:Sid")
  .asString();

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', '{{baseUrl}}/v1/Configuration/Addresses/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Configuration/Addresses/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Configuration/Addresses/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Configuration/Addresses/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Configuration/Addresses/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Configuration/Addresses/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Configuration/Addresses/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Configuration/Addresses/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Configuration/Addresses/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Configuration/Addresses/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Configuration/Addresses/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Configuration/Addresses/:Sid" in

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

 "{{baseUrl}}/v1/Configuration/Addresses/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Configuration/Addresses/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Configuration/Addresses/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Configuration/Addresses/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Configuration/Addresses/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Configuration/Addresses/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Configuration/Addresses/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Configuration/Addresses/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Configuration/Addresses/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Configuration/Addresses/:Sid")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Configuration/Addresses/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Configuration/Addresses/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Configuration/Addresses/:Sid

http GET {{baseUrl}}/v1/Configuration/Addresses/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Configuration/Addresses/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Configuration/Addresses/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchConfigurationWebhook

{{baseUrl}}/v1/Configuration/Webhooks

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Configuration/Webhooks");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Configuration/Webhooks")

require "http/client"

url = "{{baseUrl}}/v1/Configuration/Webhooks"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Configuration/Webhooks"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Configuration/Webhooks");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Configuration/Webhooks"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Configuration/Webhooks HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Configuration/Webhooks")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Configuration/Webhooks"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Configuration/Webhooks")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Configuration/Webhooks")
  .asString();

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', '{{baseUrl}}/v1/Configuration/Webhooks');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Configuration/Webhooks'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Configuration/Webhooks';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Configuration/Webhooks',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Configuration/Webhooks")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Configuration/Webhooks',
  headers: {}
};

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

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/Configuration/Webhooks'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Configuration/Webhooks');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/Configuration/Webhooks'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Configuration/Webhooks';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Configuration/Webhooks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Configuration/Webhooks" in

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

 "{{baseUrl}}/v1/Configuration/Webhooks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Configuration/Webhooks');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Configuration/Webhooks');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Configuration/Webhooks');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Configuration/Webhooks' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Configuration/Webhooks' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Configuration/Webhooks")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Configuration/Webhooks"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Configuration/Webhooks"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Configuration/Webhooks")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Configuration/Webhooks') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Configuration/Webhooks";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Configuration/Webhooks

http GET {{baseUrl}}/v1/Configuration/Webhooks

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Configuration/Webhooks

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Configuration/Webhooks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchConversation

{{baseUrl}}/v1/Conversations/:Sid

QUERY PARAMS

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Conversations/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Conversations/:Sid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Conversations/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Conversations/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Conversations/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations/:Sid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Conversations/:Sid")
  .asString();

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', '{{baseUrl}}/v1/Conversations/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Conversations/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/Conversations/:Sid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Conversations/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/Conversations/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Conversations/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations/:Sid" in

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

 "{{baseUrl}}/v1/Conversations/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Conversations/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Conversations/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Conversations/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations/:Sid")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Conversations/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Conversations/:Sid

http GET {{baseUrl}}/v1/Conversations/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Conversations/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchConversationMessage

{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid

QUERY PARAMS

ConversationSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Conversations/:ConversationSid/Messages/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid")
  .asString();

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', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations/:ConversationSid/Messages/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid" in

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

 "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Conversations/:ConversationSid/Messages/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Conversations/:ConversationSid/Messages/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid

http GET {{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchConversationMessageReceipt

{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid

QUERY PARAMS

ConversationSid

MessageSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid")
  .asString();

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', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid" in

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

 "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid

http GET {{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchConversationParticipant

{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid

QUERY PARAMS

ConversationSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Conversations/:ConversationSid/Participants/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid")
  .asString();

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', '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations/:ConversationSid/Participants/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid" in

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

 "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Conversations/:ConversationSid/Participants/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Conversations/:ConversationSid/Participants/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid

http GET {{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchConversationScopedWebhook

{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid

QUERY PARAMS

ConversationSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Conversations/:ConversationSid/Webhooks/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid")
  .asString();

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', '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations/:ConversationSid/Webhooks/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid" in

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

 "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Conversations/:ConversationSid/Webhooks/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Conversations/:ConversationSid/Webhooks/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid

http GET {{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchCredential

{{baseUrl}}/v1/Credentials/:Sid

QUERY PARAMS

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Credentials/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Credentials/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Credentials/:Sid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Credentials/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Credentials/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Credentials/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Credentials/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Credentials/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Credentials/:Sid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Credentials/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Credentials/:Sid")
  .asString();

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', '{{baseUrl}}/v1/Credentials/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Credentials/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Credentials/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Credentials/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Credentials/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Credentials/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/Credentials/:Sid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Credentials/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/Credentials/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Credentials/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Credentials/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Credentials/:Sid" in

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

 "{{baseUrl}}/v1/Credentials/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Credentials/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Credentials/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Credentials/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Credentials/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Credentials/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Credentials/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Credentials/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Credentials/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Credentials/:Sid")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Credentials/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Credentials/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Credentials/:Sid

http GET {{baseUrl}}/v1/Credentials/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Credentials/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Credentials/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchRole

{{baseUrl}}/v1/Roles/:Sid

QUERY PARAMS

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Roles/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Roles/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Roles/:Sid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Roles/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Roles/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Roles/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Roles/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Roles/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Roles/:Sid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Roles/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Roles/:Sid")
  .asString();

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', '{{baseUrl}}/v1/Roles/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Roles/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Roles/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Roles/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Roles/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Roles/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/Roles/:Sid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Roles/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/Roles/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Roles/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Roles/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Roles/:Sid" in

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

 "{{baseUrl}}/v1/Roles/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Roles/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Roles/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Roles/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Roles/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Roles/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Roles/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Roles/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Roles/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Roles/:Sid")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Roles/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Roles/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Roles/:Sid

http GET {{baseUrl}}/v1/Roles/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Roles/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Roles/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchService

{{baseUrl}}/v1/Services/:Sid

QUERY PARAMS

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:Sid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:Sid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:Sid")
  .asString();

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', '{{baseUrl}}/v1/Services/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Services/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/Services/:Sid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/Services/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:Sid" in

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

 "{{baseUrl}}/v1/Services/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:Sid")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:Sid

http GET {{baseUrl}}/v1/Services/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchServiceBinding

{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid

QUERY PARAMS

ChatServiceSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Bindings/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Bindings/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Bindings/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Bindings/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchServiceConfiguration

{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration

QUERY PARAMS

ChatServiceSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Configuration HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Configuration',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Configuration")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Configuration') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Configuration

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Configuration

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Configuration

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchServiceConversation

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid

QUERY PARAMS

ChatServiceSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Conversations/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Conversations/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Conversations/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchServiceConversationMessage

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid

QUERY PARAMS

ChatServiceSid

ConversationSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchServiceConversationMessageReceipt

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid

QUERY PARAMS

ChatServiceSid

ConversationSid

MessageSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchServiceConversationParticipant

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid

QUERY PARAMS

ChatServiceSid

ConversationSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchServiceConversationScopedWebhook

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid

QUERY PARAMS

ChatServiceSid

ConversationSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchServiceNotification

{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications

QUERY PARAMS

ChatServiceSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Configuration/Notifications HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Configuration/Notifications',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Configuration/Notifications")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Configuration/Notifications') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchServiceRole

{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid

QUERY PARAMS

ChatServiceSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Roles/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Roles/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Roles/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Roles/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchServiceUser

{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid

QUERY PARAMS

ChatServiceSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Users/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Users/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Users/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Users/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchServiceUserConversation

{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid

QUERY PARAMS

ChatServiceSid

UserSid

ConversationSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchServiceWebhookConfiguration

{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks

QUERY PARAMS

ChatServiceSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Configuration/Webhooks HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Configuration/Webhooks',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks" in

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

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Configuration/Webhooks")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Configuration/Webhooks') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchUser

{{baseUrl}}/v1/Users/:Sid

QUERY PARAMS

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Users/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Users/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Users/:Sid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Users/:Sid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Users/:Sid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Users/:Sid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Users/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Users/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Users/:Sid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Users/:Sid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Users/:Sid")
  .asString();

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', '{{baseUrl}}/v1/Users/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Users/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Users/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Users/:Sid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Users/:Sid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Users/:Sid',
  headers: {}
};

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

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/Users/:Sid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Users/:Sid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/Users/:Sid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Users/:Sid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Users/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Users/:Sid" in

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

 "{{baseUrl}}/v1/Users/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Users/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Users/:Sid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Users/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Users/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Users/:Sid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Users/:Sid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Users/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Users/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Users/:Sid")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Users/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Users/:Sid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Users/:Sid

http GET {{baseUrl}}/v1/Users/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Users/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Users/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET FetchUserConversation

{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid

QUERY PARAMS

UserSid

ConversationSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid")

require "http/client"

url = "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Users/:UserSid/Conversations/:ConversationSid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid")
  .asString();

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', '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Users/:UserSid/Conversations/:ConversationSid',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid" in

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

 "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Users/:UserSid/Conversations/:ConversationSid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Users/:UserSid/Conversations/:ConversationSid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid

http GET {{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListConfigurationAddress

{{baseUrl}}/v1/Configuration/Addresses

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Configuration/Addresses");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Configuration/Addresses")

require "http/client"

url = "{{baseUrl}}/v1/Configuration/Addresses"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Configuration/Addresses"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Configuration/Addresses");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Configuration/Addresses"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Configuration/Addresses HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Configuration/Addresses")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Configuration/Addresses"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Configuration/Addresses")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Configuration/Addresses")
  .asString();

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', '{{baseUrl}}/v1/Configuration/Addresses');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Configuration/Addresses'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Configuration/Addresses';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Configuration/Addresses',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Configuration/Addresses")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Configuration/Addresses',
  headers: {}
};

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

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/Configuration/Addresses'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Configuration/Addresses');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/Configuration/Addresses'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Configuration/Addresses';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Configuration/Addresses"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Configuration/Addresses" in

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

 "{{baseUrl}}/v1/Configuration/Addresses",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Configuration/Addresses');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Configuration/Addresses');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Configuration/Addresses');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Configuration/Addresses' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Configuration/Addresses' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Configuration/Addresses")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Configuration/Addresses"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Configuration/Addresses"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Configuration/Addresses")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Configuration/Addresses') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Configuration/Addresses";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Configuration/Addresses

http GET {{baseUrl}}/v1/Configuration/Addresses

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Configuration/Addresses

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Configuration/Addresses")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListConversation

{{baseUrl}}/v1/Conversations

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Conversations")

require "http/client"

url = "{{baseUrl}}/v1/Conversations"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Conversations"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Conversations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Conversations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Conversations")
  .asString();

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', '{{baseUrl}}/v1/Conversations');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Conversations'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations',
  headers: {}
};

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

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/Conversations'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Conversations');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/Conversations'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Conversations';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations" in

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

 "{{baseUrl}}/v1/Conversations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Conversations');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Conversations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Conversations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Conversations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Conversations

http GET {{baseUrl}}/v1/Conversations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Conversations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListConversationMessage

{{baseUrl}}/v1/Conversations/:ConversationSid/Messages

QUERY PARAMS

ConversationSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages")

require "http/client"

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Conversations/:ConversationSid/Messages HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages")
  .asString();

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', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations/:ConversationSid/Messages',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations/:ConversationSid/Messages"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages" in

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

 "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Messages');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Messages');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Conversations/:ConversationSid/Messages")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Conversations/:ConversationSid/Messages') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Conversations/:ConversationSid/Messages

http GET {{baseUrl}}/v1/Conversations/:ConversationSid/Messages

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Conversations/:ConversationSid/Messages

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListConversationMessageReceipt

{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts

QUERY PARAMS

ConversationSid

MessageSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts")

require "http/client"

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts")
  .asString();

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', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts" in

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

 "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts

http GET {{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:MessageSid/Receipts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListConversationParticipant

{{baseUrl}}/v1/Conversations/:ConversationSid/Participants

QUERY PARAMS

ConversationSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants")

require "http/client"

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Conversations/:ConversationSid/Participants HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants")
  .asString();

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', '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations/:ConversationSid/Participants',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations/:ConversationSid/Participants"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants" in

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

 "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Participants');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Participants');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Conversations/:ConversationSid/Participants")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Conversations/:ConversationSid/Participants') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Conversations/:ConversationSid/Participants

http GET {{baseUrl}}/v1/Conversations/:ConversationSid/Participants

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Conversations/:ConversationSid/Participants

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListConversationScopedWebhook

{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks

QUERY PARAMS

ConversationSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks")

require "http/client"

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Conversations/:ConversationSid/Webhooks HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks")
  .asString();

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', '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations/:ConversationSid/Webhooks',
  headers: {}
};

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

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks" in

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

 "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Conversations/:ConversationSid/Webhooks")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Conversations/:ConversationSid/Webhooks') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks

http GET {{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListCredential

{{baseUrl}}/v1/Credentials

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Credentials");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Credentials")

require "http/client"

url = "{{baseUrl}}/v1/Credentials"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Credentials"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Credentials");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Credentials"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Credentials HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Credentials")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Credentials"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Credentials")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Credentials")
  .asString();

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', '{{baseUrl}}/v1/Credentials');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Credentials'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Credentials';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Credentials',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Credentials")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Credentials',
  headers: {}
};

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

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/Credentials'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Credentials');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/Credentials'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Credentials';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Credentials"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Credentials" in

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

 "{{baseUrl}}/v1/Credentials",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Credentials');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Credentials');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Credentials');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Credentials' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Credentials' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Credentials")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Credentials"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Credentials"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Credentials")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Credentials') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Credentials";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Credentials

http GET {{baseUrl}}/v1/Credentials

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Credentials

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Credentials")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListParticipantConversation

{{baseUrl}}/v1/ParticipantConversations

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/ParticipantConversations");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/ParticipantConversations")

require "http/client"

url = "{{baseUrl}}/v1/ParticipantConversations"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/ParticipantConversations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/ParticipantConversations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/ParticipantConversations"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/ParticipantConversations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/ParticipantConversations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/ParticipantConversations"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/ParticipantConversations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/ParticipantConversations")
  .asString();

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', '{{baseUrl}}/v1/ParticipantConversations');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/ParticipantConversations'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/ParticipantConversations';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/ParticipantConversations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/ParticipantConversations")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/ParticipantConversations',
  headers: {}
};

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

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/ParticipantConversations'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/ParticipantConversations');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/ParticipantConversations'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/ParticipantConversations';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/ParticipantConversations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/ParticipantConversations" in

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

 "{{baseUrl}}/v1/ParticipantConversations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/ParticipantConversations');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/ParticipantConversations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/ParticipantConversations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/ParticipantConversations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/ParticipantConversations' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/ParticipantConversations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/ParticipantConversations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/ParticipantConversations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/ParticipantConversations")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/ParticipantConversations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/ParticipantConversations";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/ParticipantConversations

http GET {{baseUrl}}/v1/ParticipantConversations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/ParticipantConversations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/ParticipantConversations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListRole

{{baseUrl}}/v1/Roles

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Roles");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Roles")

require "http/client"

url = "{{baseUrl}}/v1/Roles"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Roles"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Roles");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Roles"

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

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Roles HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Roles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Roles"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Roles")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Roles")
  .asString();

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', '{{baseUrl}}/v1/Roles');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Roles'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Roles';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Roles',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Roles")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Roles',
  headers: {}
};

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

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/Roles'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Roles');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/Roles'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Roles';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Roles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Roles" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Roles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Roles');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Roles');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Roles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Roles' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Roles' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Roles")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Roles"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Roles"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Roles")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Roles') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Roles";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Roles

http GET {{baseUrl}}/v1/Roles

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Roles

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Roles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListService

{{baseUrl}}/v1/Services

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services")

require "http/client"

url = "{{baseUrl}}/v1/Services"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services")
  .asString();

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', '{{baseUrl}}/v1/Services');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Services'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services',
  headers: {}
};

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();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/Services'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/Services'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services

http GET {{baseUrl}}/v1/Services

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListServiceBinding

{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings

QUERY PARAMS

ChatServiceSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Bindings HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Bindings',
  headers: {}
};

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();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Bindings")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Bindings') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Bindings

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Bindings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Bindings

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Bindings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListServiceConversation

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations

QUERY PARAMS

ChatServiceSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Conversations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations',
  headers: {}
};

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();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Conversations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Conversations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListServiceConversationMessage

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages

QUERY PARAMS

ChatServiceSid

ConversationSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages',
  headers: {}
};

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();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListServiceConversationMessageReceipt

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts

QUERY PARAMS

ChatServiceSid

ConversationSid

MessageSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts',
  headers: {}
};

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();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:MessageSid/Receipts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListServiceConversationParticipant

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants

QUERY PARAMS

ChatServiceSid

ConversationSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants',
  headers: {}
};

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();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListServiceConversationScopedWebhook

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks

QUERY PARAMS

ChatServiceSid

ConversationSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks',
  headers: {}
};

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();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListServiceParticipantConversation

{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations

QUERY PARAMS

ChatServiceSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/ParticipantConversations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/ParticipantConversations',
  headers: {}
};

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();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/ParticipantConversations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/ParticipantConversations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/ParticipantConversations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListServiceRole

{{baseUrl}}/v1/Services/:ChatServiceSid/Roles

QUERY PARAMS

ChatServiceSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Roles HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Roles',
  headers: {}
};

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();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Roles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Roles');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Roles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Roles")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Roles') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Roles

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Roles

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Roles

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListServiceUser

{{baseUrl}}/v1/Services/:ChatServiceSid/Users

QUERY PARAMS

ChatServiceSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Users");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Users")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Users"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Users");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Users"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Users HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Users")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Users"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Users")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Users")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Users';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Users")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Users',
  headers: {}
};

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();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Users';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Users"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Users" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Users",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Users');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Users');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Users' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Users' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Users")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Users"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Users")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Users') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Users

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Users

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Users

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Users")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListServiceUserConversation

{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations

QUERY PARAMS

ChatServiceSid

UserSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations")
  .asString();

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', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations',
  headers: {}
};

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();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations

http GET {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListUser

{{baseUrl}}/v1/Users

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Users");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Users")

require "http/client"

url = "{{baseUrl}}/v1/Users"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Users"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Users");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Users"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Users HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Users")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Users"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Users")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Users")
  .asString();

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', '{{baseUrl}}/v1/Users');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/Users'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Users';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Users',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Users")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Users',
  headers: {}
};

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();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/Users'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Users');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/Users'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Users';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Users"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Users" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Users",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Users');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Users');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Users');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Users' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Users' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Users")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Users"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Users"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Users")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Users') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Users";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Users

http GET {{baseUrl}}/v1/Users

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Users

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Users")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListUserConversation

{{baseUrl}}/v1/Users/:UserSid/Conversations

QUERY PARAMS

UserSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Users/:UserSid/Conversations");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/Users/:UserSid/Conversations")

require "http/client"

url = "{{baseUrl}}/v1/Users/:UserSid/Conversations"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/Users/:UserSid/Conversations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Users/:UserSid/Conversations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Users/:UserSid/Conversations"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/Users/:UserSid/Conversations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Users/:UserSid/Conversations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Users/:UserSid/Conversations"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Users/:UserSid/Conversations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Users/:UserSid/Conversations")
  .asString();

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', '{{baseUrl}}/v1/Users/:UserSid/Conversations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Users/:UserSid/Conversations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Users/:UserSid/Conversations';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Users/:UserSid/Conversations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Users/:UserSid/Conversations")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Users/:UserSid/Conversations',
  headers: {}
};

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();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Users/:UserSid/Conversations'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/Users/:UserSid/Conversations');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Users/:UserSid/Conversations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/Users/:UserSid/Conversations';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Users/:UserSid/Conversations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Users/:UserSid/Conversations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Users/:UserSid/Conversations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/Users/:UserSid/Conversations');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Users/:UserSid/Conversations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/Users/:UserSid/Conversations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Users/:UserSid/Conversations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Users/:UserSid/Conversations' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/Users/:UserSid/Conversations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Users/:UserSid/Conversations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Users/:UserSid/Conversations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Users/:UserSid/Conversations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/Users/:UserSid/Conversations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Users/:UserSid/Conversations";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1/Users/:UserSid/Conversations

http GET {{baseUrl}}/v1/Users/:UserSid/Conversations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Users/:UserSid/Conversations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Users/:UserSid/Conversations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateConfiguration

{{baseUrl}}/v1/Configuration

BODY formUrlEncoded

DefaultChatServiceSid

DefaultClosedTimer

DefaultInactiveTimer

DefaultMessagingServiceSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Configuration");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "DefaultChatServiceSid=&DefaultClosedTimer=&DefaultInactiveTimer=&DefaultMessagingServiceSid=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Configuration" {:form-params {:DefaultChatServiceSid ""
                                                                           :DefaultClosedTimer ""
                                                                           :DefaultInactiveTimer ""
                                                                           :DefaultMessagingServiceSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Configuration"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "DefaultChatServiceSid=&DefaultClosedTimer=&DefaultInactiveTimer=&DefaultMessagingServiceSid="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Configuration"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "DefaultChatServiceSid", "" },
        { "DefaultClosedTimer", "" },
        { "DefaultInactiveTimer", "" },
        { "DefaultMessagingServiceSid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Configuration");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "DefaultChatServiceSid=&DefaultClosedTimer=&DefaultInactiveTimer=&DefaultMessagingServiceSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Configuration"

	payload := strings.NewReader("DefaultChatServiceSid=&DefaultClosedTimer=&DefaultInactiveTimer=&DefaultMessagingServiceSid=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Configuration HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 92

DefaultChatServiceSid=&DefaultClosedTimer=&DefaultInactiveTimer=&DefaultMessagingServiceSid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Configuration")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("DefaultChatServiceSid=&DefaultClosedTimer=&DefaultInactiveTimer=&DefaultMessagingServiceSid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Configuration"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("DefaultChatServiceSid=&DefaultClosedTimer=&DefaultInactiveTimer=&DefaultMessagingServiceSid="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "DefaultChatServiceSid=&DefaultClosedTimer=&DefaultInactiveTimer=&DefaultMessagingServiceSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Configuration")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Configuration")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("DefaultChatServiceSid=&DefaultClosedTimer=&DefaultInactiveTimer=&DefaultMessagingServiceSid=")
  .asString();

const data = 'DefaultChatServiceSid=&DefaultClosedTimer=&DefaultInactiveTimer=&DefaultMessagingServiceSid=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Configuration');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('DefaultChatServiceSid', '');
encodedParams.set('DefaultClosedTimer', '');
encodedParams.set('DefaultInactiveTimer', '');
encodedParams.set('DefaultMessagingServiceSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Configuration',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Configuration';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    DefaultChatServiceSid: '',
    DefaultClosedTimer: '',
    DefaultInactiveTimer: '',
    DefaultMessagingServiceSid: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Configuration',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    DefaultChatServiceSid: '',
    DefaultClosedTimer: '',
    DefaultInactiveTimer: '',
    DefaultMessagingServiceSid: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "DefaultChatServiceSid=&DefaultClosedTimer=&DefaultInactiveTimer=&DefaultMessagingServiceSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Configuration")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Configuration',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  DefaultChatServiceSid: '',
  DefaultClosedTimer: '',
  DefaultInactiveTimer: '',
  DefaultMessagingServiceSid: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Configuration',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    DefaultChatServiceSid: '',
    DefaultClosedTimer: '',
    DefaultInactiveTimer: '',
    DefaultMessagingServiceSid: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Configuration');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  DefaultChatServiceSid: '',
  DefaultClosedTimer: '',
  DefaultInactiveTimer: '',
  DefaultMessagingServiceSid: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('DefaultChatServiceSid', '');
encodedParams.set('DefaultClosedTimer', '');
encodedParams.set('DefaultInactiveTimer', '');
encodedParams.set('DefaultMessagingServiceSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Configuration',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('DefaultChatServiceSid', '');
encodedParams.set('DefaultClosedTimer', '');
encodedParams.set('DefaultInactiveTimer', '');
encodedParams.set('DefaultMessagingServiceSid', '');

const url = '{{baseUrl}}/v1/Configuration';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"DefaultChatServiceSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DefaultClosedTimer=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DefaultInactiveTimer=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DefaultMessagingServiceSid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Configuration"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Configuration" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "DefaultChatServiceSid=&DefaultClosedTimer=&DefaultInactiveTimer=&DefaultMessagingServiceSid=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Configuration",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "DefaultChatServiceSid=&DefaultClosedTimer=&DefaultInactiveTimer=&DefaultMessagingServiceSid=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Configuration', [
  'form_params' => [
    'DefaultChatServiceSid' => '',
    'DefaultClosedTimer' => '',
    'DefaultInactiveTimer' => '',
    'DefaultMessagingServiceSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Configuration');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'DefaultChatServiceSid' => '',
  'DefaultClosedTimer' => '',
  'DefaultInactiveTimer' => '',
  'DefaultMessagingServiceSid' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'DefaultChatServiceSid' => '',
  'DefaultClosedTimer' => '',
  'DefaultInactiveTimer' => '',
  'DefaultMessagingServiceSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Configuration');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Configuration' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'DefaultChatServiceSid=&DefaultClosedTimer=&DefaultInactiveTimer=&DefaultMessagingServiceSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Configuration' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'DefaultChatServiceSid=&DefaultClosedTimer=&DefaultInactiveTimer=&DefaultMessagingServiceSid='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "DefaultChatServiceSid=&DefaultClosedTimer=&DefaultInactiveTimer=&DefaultMessagingServiceSid="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Configuration", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Configuration"

payload = {
    "DefaultChatServiceSid": "",
    "DefaultClosedTimer": "",
    "DefaultInactiveTimer": "",
    "DefaultMessagingServiceSid": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Configuration"

payload <- "DefaultChatServiceSid=&DefaultClosedTimer=&DefaultInactiveTimer=&DefaultMessagingServiceSid="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Configuration")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "DefaultChatServiceSid=&DefaultClosedTimer=&DefaultInactiveTimer=&DefaultMessagingServiceSid="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :DefaultChatServiceSid => "",
  :DefaultClosedTimer => "",
  :DefaultInactiveTimer => "",
  :DefaultMessagingServiceSid => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Configuration') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Configuration";

    let payload = json!({
        "DefaultChatServiceSid": "",
        "DefaultClosedTimer": "",
        "DefaultInactiveTimer": "",
        "DefaultMessagingServiceSid": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Configuration \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data DefaultChatServiceSid= \
  --data DefaultClosedTimer= \
  --data DefaultInactiveTimer= \
  --data DefaultMessagingServiceSid=

http --form POST {{baseUrl}}/v1/Configuration \
  content-type:application/x-www-form-urlencoded \
  DefaultChatServiceSid='' \
  DefaultClosedTimer='' \
  DefaultInactiveTimer='' \
  DefaultMessagingServiceSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'DefaultChatServiceSid=&DefaultClosedTimer=&DefaultInactiveTimer=&DefaultMessagingServiceSid=' \
  --output-document \
  - {{baseUrl}}/v1/Configuration

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "DefaultChatServiceSid=".data(using: String.Encoding.utf8)!)
postData.append("&DefaultClosedTimer=".data(using: String.Encoding.utf8)!)
postData.append("&DefaultInactiveTimer=".data(using: String.Encoding.utf8)!)
postData.append("&DefaultMessagingServiceSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Configuration")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateConfigurationAddress

{{baseUrl}}/v1/Configuration/Addresses/:Sid

QUERY PARAMS

Sid

BODY formUrlEncoded

AutoCreation.ConversationServiceSid

AutoCreation.Enabled

AutoCreation.StudioFlowSid

AutoCreation.StudioRetryCount

AutoCreation.Type

AutoCreation.WebhookFilters

AutoCreation.WebhookMethod

AutoCreation.WebhookUrl

FriendlyName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Configuration/Addresses/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Configuration/Addresses/:Sid" {:form-params {:AutoCreation.ConversationServiceSid ""
                                                                                          :AutoCreation.Enabled ""
                                                                                          :AutoCreation.StudioFlowSid ""
                                                                                          :AutoCreation.StudioRetryCount ""
                                                                                          :AutoCreation.Type ""
                                                                                          :AutoCreation.WebhookFilters ""
                                                                                          :AutoCreation.WebhookMethod ""
                                                                                          :AutoCreation.WebhookUrl ""
                                                                                          :FriendlyName ""}})

require "http/client"

url = "{{baseUrl}}/v1/Configuration/Addresses/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Configuration/Addresses/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "AutoCreation.ConversationServiceSid", "" },
        { "AutoCreation.Enabled", "" },
        { "AutoCreation.StudioFlowSid", "" },
        { "AutoCreation.StudioRetryCount", "" },
        { "AutoCreation.Type", "" },
        { "AutoCreation.WebhookFilters", "" },
        { "AutoCreation.WebhookMethod", "" },
        { "AutoCreation.WebhookUrl", "" },
        { "FriendlyName", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Configuration/Addresses/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Configuration/Addresses/:Sid"

	payload := strings.NewReader("AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Configuration/Addresses/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 232

AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Configuration/Addresses/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Configuration/Addresses/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Configuration/Addresses/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Configuration/Addresses/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=")
  .asString();

const data = 'AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Configuration/Addresses/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('AutoCreation.ConversationServiceSid', '');
encodedParams.set('AutoCreation.Enabled', '');
encodedParams.set('AutoCreation.StudioFlowSid', '');
encodedParams.set('AutoCreation.StudioRetryCount', '');
encodedParams.set('AutoCreation.Type', '');
encodedParams.set('AutoCreation.WebhookFilters', '');
encodedParams.set('AutoCreation.WebhookMethod', '');
encodedParams.set('AutoCreation.WebhookUrl', '');
encodedParams.set('FriendlyName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Configuration/Addresses/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Configuration/Addresses/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    'AutoCreation.ConversationServiceSid': '',
    'AutoCreation.Enabled': '',
    'AutoCreation.StudioFlowSid': '',
    'AutoCreation.StudioRetryCount': '',
    'AutoCreation.Type': '',
    'AutoCreation.WebhookFilters': '',
    'AutoCreation.WebhookMethod': '',
    'AutoCreation.WebhookUrl': '',
    FriendlyName: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Configuration/Addresses/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    'AutoCreation.ConversationServiceSid': '',
    'AutoCreation.Enabled': '',
    'AutoCreation.StudioFlowSid': '',
    'AutoCreation.StudioRetryCount': '',
    'AutoCreation.Type': '',
    'AutoCreation.WebhookFilters': '',
    'AutoCreation.WebhookMethod': '',
    'AutoCreation.WebhookUrl': '',
    FriendlyName: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Configuration/Addresses/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Configuration/Addresses/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  'AutoCreation.ConversationServiceSid': '',
  'AutoCreation.Enabled': '',
  'AutoCreation.StudioFlowSid': '',
  'AutoCreation.StudioRetryCount': '',
  'AutoCreation.Type': '',
  'AutoCreation.WebhookFilters': '',
  'AutoCreation.WebhookMethod': '',
  'AutoCreation.WebhookUrl': '',
  FriendlyName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Configuration/Addresses/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    'AutoCreation.ConversationServiceSid': '',
    'AutoCreation.Enabled': '',
    'AutoCreation.StudioFlowSid': '',
    'AutoCreation.StudioRetryCount': '',
    'AutoCreation.Type': '',
    'AutoCreation.WebhookFilters': '',
    'AutoCreation.WebhookMethod': '',
    'AutoCreation.WebhookUrl': '',
    FriendlyName: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Configuration/Addresses/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  'AutoCreation.ConversationServiceSid': '',
  'AutoCreation.Enabled': '',
  'AutoCreation.StudioFlowSid': '',
  'AutoCreation.StudioRetryCount': '',
  'AutoCreation.Type': '',
  'AutoCreation.WebhookFilters': '',
  'AutoCreation.WebhookMethod': '',
  'AutoCreation.WebhookUrl': '',
  FriendlyName: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('AutoCreation.ConversationServiceSid', '');
encodedParams.set('AutoCreation.Enabled', '');
encodedParams.set('AutoCreation.StudioFlowSid', '');
encodedParams.set('AutoCreation.StudioRetryCount', '');
encodedParams.set('AutoCreation.Type', '');
encodedParams.set('AutoCreation.WebhookFilters', '');
encodedParams.set('AutoCreation.WebhookMethod', '');
encodedParams.set('AutoCreation.WebhookUrl', '');
encodedParams.set('FriendlyName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Configuration/Addresses/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('AutoCreation.ConversationServiceSid', '');
encodedParams.set('AutoCreation.Enabled', '');
encodedParams.set('AutoCreation.StudioFlowSid', '');
encodedParams.set('AutoCreation.StudioRetryCount', '');
encodedParams.set('AutoCreation.Type', '');
encodedParams.set('AutoCreation.WebhookFilters', '');
encodedParams.set('AutoCreation.WebhookMethod', '');
encodedParams.set('AutoCreation.WebhookUrl', '');
encodedParams.set('FriendlyName', '');

const url = '{{baseUrl}}/v1/Configuration/Addresses/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"AutoCreation.ConversationServiceSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AutoCreation.Enabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AutoCreation.StudioFlowSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AutoCreation.StudioRetryCount=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AutoCreation.Type=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AutoCreation.WebhookFilters=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AutoCreation.WebhookMethod=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AutoCreation.WebhookUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Configuration/Addresses/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Configuration/Addresses/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Configuration/Addresses/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Configuration/Addresses/:Sid', [
  'form_params' => [
    'AutoCreation.ConversationServiceSid' => '',
    'AutoCreation.Enabled' => '',
    'AutoCreation.StudioFlowSid' => '',
    'AutoCreation.StudioRetryCount' => '',
    'AutoCreation.Type' => '',
    'AutoCreation.WebhookFilters' => '',
    'AutoCreation.WebhookMethod' => '',
    'AutoCreation.WebhookUrl' => '',
    'FriendlyName' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Configuration/Addresses/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'AutoCreation.ConversationServiceSid' => '',
  'AutoCreation.Enabled' => '',
  'AutoCreation.StudioFlowSid' => '',
  'AutoCreation.StudioRetryCount' => '',
  'AutoCreation.Type' => '',
  'AutoCreation.WebhookFilters' => '',
  'AutoCreation.WebhookMethod' => '',
  'AutoCreation.WebhookUrl' => '',
  'FriendlyName' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'AutoCreation.ConversationServiceSid' => '',
  'AutoCreation.Enabled' => '',
  'AutoCreation.StudioFlowSid' => '',
  'AutoCreation.StudioRetryCount' => '',
  'AutoCreation.Type' => '',
  'AutoCreation.WebhookFilters' => '',
  'AutoCreation.WebhookMethod' => '',
  'AutoCreation.WebhookUrl' => '',
  'FriendlyName' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Configuration/Addresses/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Configuration/Addresses/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Configuration/Addresses/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Configuration/Addresses/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Configuration/Addresses/:Sid"

payload = {
    "AutoCreation.ConversationServiceSid": "",
    "AutoCreation.Enabled": "",
    "AutoCreation.StudioFlowSid": "",
    "AutoCreation.StudioRetryCount": "",
    "AutoCreation.Type": "",
    "AutoCreation.WebhookFilters": "",
    "AutoCreation.WebhookMethod": "",
    "AutoCreation.WebhookUrl": "",
    "FriendlyName": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Configuration/Addresses/:Sid"

payload <- "AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Configuration/Addresses/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :AutoCreation.ConversationServiceSid => "",
  :AutoCreation.Enabled => "",
  :AutoCreation.StudioFlowSid => "",
  :AutoCreation.StudioRetryCount => "",
  :AutoCreation.Type => "",
  :AutoCreation.WebhookFilters => "",
  :AutoCreation.WebhookMethod => "",
  :AutoCreation.WebhookUrl => "",
  :FriendlyName => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Configuration/Addresses/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Configuration/Addresses/:Sid";

    let payload = json!({
        "AutoCreation.ConversationServiceSid": "",
        "AutoCreation.Enabled": "",
        "AutoCreation.StudioFlowSid": "",
        "AutoCreation.StudioRetryCount": "",
        "AutoCreation.Type": "",
        "AutoCreation.WebhookFilters": "",
        "AutoCreation.WebhookMethod": "",
        "AutoCreation.WebhookUrl": "",
        "FriendlyName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Configuration/Addresses/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data AutoCreation.ConversationServiceSid= \
  --data AutoCreation.Enabled= \
  --data AutoCreation.StudioFlowSid= \
  --data AutoCreation.StudioRetryCount= \
  --data AutoCreation.Type= \
  --data AutoCreation.WebhookFilters= \
  --data AutoCreation.WebhookMethod= \
  --data AutoCreation.WebhookUrl= \
  --data FriendlyName=

http --form POST {{baseUrl}}/v1/Configuration/Addresses/:Sid \
  content-type:application/x-www-form-urlencoded \
  AutoCreation.ConversationServiceSid='' \
  AutoCreation.Enabled='' \
  AutoCreation.StudioFlowSid='' \
  AutoCreation.StudioRetryCount='' \
  AutoCreation.Type='' \
  AutoCreation.WebhookFilters='' \
  AutoCreation.WebhookMethod='' \
  AutoCreation.WebhookUrl='' \
  FriendlyName=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'AutoCreation.ConversationServiceSid=&AutoCreation.Enabled=&AutoCreation.StudioFlowSid=&AutoCreation.StudioRetryCount=&AutoCreation.Type=&AutoCreation.WebhookFilters=&AutoCreation.WebhookMethod=&AutoCreation.WebhookUrl=&FriendlyName=' \
  --output-document \
  - {{baseUrl}}/v1/Configuration/Addresses/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "AutoCreation.ConversationServiceSid=".data(using: String.Encoding.utf8)!)
postData.append("&AutoCreation.Enabled=".data(using: String.Encoding.utf8)!)
postData.append("&AutoCreation.StudioFlowSid=".data(using: String.Encoding.utf8)!)
postData.append("&AutoCreation.StudioRetryCount=".data(using: String.Encoding.utf8)!)
postData.append("&AutoCreation.Type=".data(using: String.Encoding.utf8)!)
postData.append("&AutoCreation.WebhookFilters=".data(using: String.Encoding.utf8)!)
postData.append("&AutoCreation.WebhookMethod=".data(using: String.Encoding.utf8)!)
postData.append("&AutoCreation.WebhookUrl=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Configuration/Addresses/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateConfigurationWebhook

{{baseUrl}}/v1/Configuration/Webhooks

BODY formUrlEncoded

Filters

Method

PostWebhookUrl

PreWebhookUrl

Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Configuration/Webhooks");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=&Target=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Configuration/Webhooks" {:form-params {:Filters ""
                                                                                    :Method ""
                                                                                    :PostWebhookUrl ""
                                                                                    :PreWebhookUrl ""
                                                                                    :Target ""}})

require "http/client"

url = "{{baseUrl}}/v1/Configuration/Webhooks"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=&Target="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Configuration/Webhooks"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Filters", "" },
        { "Method", "" },
        { "PostWebhookUrl", "" },
        { "PreWebhookUrl", "" },
        { "Target", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Configuration/Webhooks");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=&Target=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Configuration/Webhooks"

	payload := strings.NewReader("Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=&Target=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Configuration/Webhooks HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 55

Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=&Target=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Configuration/Webhooks")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=&Target=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Configuration/Webhooks"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=&Target="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=&Target=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Configuration/Webhooks")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Configuration/Webhooks")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=&Target=")
  .asString();

const data = 'Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=&Target=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Configuration/Webhooks');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Filters', '');
encodedParams.set('Method', '');
encodedParams.set('PostWebhookUrl', '');
encodedParams.set('PreWebhookUrl', '');
encodedParams.set('Target', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Configuration/Webhooks',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Configuration/Webhooks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Filters: '', Method: '', PostWebhookUrl: '', PreWebhookUrl: '', Target: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Configuration/Webhooks',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Filters: '',
    Method: '',
    PostWebhookUrl: '',
    PreWebhookUrl: '',
    Target: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=&Target=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Configuration/Webhooks")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Configuration/Webhooks',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({Filters: '', Method: '', PostWebhookUrl: '', PreWebhookUrl: '', Target: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Configuration/Webhooks',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Filters: '', Method: '', PostWebhookUrl: '', PreWebhookUrl: '', Target: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Configuration/Webhooks');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Filters: '',
  Method: '',
  PostWebhookUrl: '',
  PreWebhookUrl: '',
  Target: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Filters', '');
encodedParams.set('Method', '');
encodedParams.set('PostWebhookUrl', '');
encodedParams.set('PreWebhookUrl', '');
encodedParams.set('Target', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Configuration/Webhooks',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Filters', '');
encodedParams.set('Method', '');
encodedParams.set('PostWebhookUrl', '');
encodedParams.set('PreWebhookUrl', '');
encodedParams.set('Target', '');

const url = '{{baseUrl}}/v1/Configuration/Webhooks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Filters=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&PostWebhookUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&PreWebhookUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Target=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Configuration/Webhooks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Configuration/Webhooks" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=&Target=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Configuration/Webhooks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=&Target=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Configuration/Webhooks', [
  'form_params' => [
    'Filters' => '',
    'Method' => '',
    'PostWebhookUrl' => '',
    'PreWebhookUrl' => '',
    'Target' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Configuration/Webhooks');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Filters' => '',
  'Method' => '',
  'PostWebhookUrl' => '',
  'PreWebhookUrl' => '',
  'Target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Filters' => '',
  'Method' => '',
  'PostWebhookUrl' => '',
  'PreWebhookUrl' => '',
  'Target' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Configuration/Webhooks');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Configuration/Webhooks' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=&Target='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Configuration/Webhooks' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=&Target='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=&Target="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Configuration/Webhooks", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Configuration/Webhooks"

payload = {
    "Filters": "",
    "Method": "",
    "PostWebhookUrl": "",
    "PreWebhookUrl": "",
    "Target": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Configuration/Webhooks"

payload <- "Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=&Target="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Configuration/Webhooks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=&Target="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Filters => "",
  :Method => "",
  :PostWebhookUrl => "",
  :PreWebhookUrl => "",
  :Target => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Configuration/Webhooks') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Configuration/Webhooks";

    let payload = json!({
        "Filters": "",
        "Method": "",
        "PostWebhookUrl": "",
        "PreWebhookUrl": "",
        "Target": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Configuration/Webhooks \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Filters= \
  --data Method= \
  --data PostWebhookUrl= \
  --data PreWebhookUrl= \
  --data Target=

http --form POST {{baseUrl}}/v1/Configuration/Webhooks \
  content-type:application/x-www-form-urlencoded \
  Filters='' \
  Method='' \
  PostWebhookUrl='' \
  PreWebhookUrl='' \
  Target=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=&Target=' \
  --output-document \
  - {{baseUrl}}/v1/Configuration/Webhooks

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Filters=".data(using: String.Encoding.utf8)!)
postData.append("&Method=".data(using: String.Encoding.utf8)!)
postData.append("&PostWebhookUrl=".data(using: String.Encoding.utf8)!)
postData.append("&PreWebhookUrl=".data(using: String.Encoding.utf8)!)
postData.append("&Target=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Configuration/Webhooks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateConversation

{{baseUrl}}/v1/Conversations/:Sid

QUERY PARAMS

Sid

BODY formUrlEncoded

Attributes

DateCreated

DateUpdated

FriendlyName

MessagingServiceSid

State

Timers.Closed

Timers.Inactive

UniqueName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Conversations/:Sid" {:form-params {:Attributes ""
                                                                                :DateCreated ""
                                                                                :DateUpdated ""
                                                                                :FriendlyName ""
                                                                                :MessagingServiceSid ""
                                                                                :State ""
                                                                                :Timers.Closed ""
                                                                                :Timers.Inactive ""
                                                                                :UniqueName ""}})

require "http/client"

url = "{{baseUrl}}/v1/Conversations/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "DateCreated", "" },
        { "DateUpdated", "" },
        { "FriendlyName", "" },
        { "MessagingServiceSid", "" },
        { "State", "" },
        { "Timers.Closed", "" },
        { "Timers.Inactive", "" },
        { "UniqueName", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Conversations/:Sid"

	payload := strings.NewReader("Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Conversations/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 123

Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Conversations/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Conversations/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=")
  .asString();

const data = 'Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Conversations/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('MessagingServiceSid', '');
encodedParams.set('State', '');
encodedParams.set('Timers.Closed', '');
encodedParams.set('Timers.Inactive', '');
encodedParams.set('UniqueName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    FriendlyName: '',
    MessagingServiceSid: '',
    State: '',
    'Timers.Closed': '',
    'Timers.Inactive': '',
    UniqueName: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    FriendlyName: '',
    MessagingServiceSid: '',
    State: '',
    'Timers.Closed': '',
    'Timers.Inactive': '',
    UniqueName: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  Attributes: '',
  DateCreated: '',
  DateUpdated: '',
  FriendlyName: '',
  MessagingServiceSid: '',
  State: '',
  'Timers.Closed': '',
  'Timers.Inactive': '',
  UniqueName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    FriendlyName: '',
    MessagingServiceSid: '',
    State: '',
    'Timers.Closed': '',
    'Timers.Inactive': '',
    UniqueName: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Conversations/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Attributes: '',
  DateCreated: '',
  DateUpdated: '',
  FriendlyName: '',
  MessagingServiceSid: '',
  State: '',
  'Timers.Closed': '',
  'Timers.Inactive': '',
  UniqueName: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('MessagingServiceSid', '');
encodedParams.set('State', '');
encodedParams.set('Timers.Closed', '');
encodedParams.set('Timers.Inactive', '');
encodedParams.set('UniqueName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('MessagingServiceSid', '');
encodedParams.set('State', '');
encodedParams.set('Timers.Closed', '');
encodedParams.set('Timers.Inactive', '');
encodedParams.set('UniqueName', '');

const url = '{{baseUrl}}/v1/Conversations/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateCreated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateUpdated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MessagingServiceSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&State=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Timers.Closed=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Timers.Inactive=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UniqueName=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Conversations/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Conversations/:Sid', [
  'form_params' => [
    'Attributes' => '',
    'DateCreated' => '',
    'DateUpdated' => '',
    'FriendlyName' => '',
    'MessagingServiceSid' => '',
    'State' => '',
    'Timers.Closed' => '',
    'Timers.Inactive' => '',
    'UniqueName' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Attributes' => '',
  'DateCreated' => '',
  'DateUpdated' => '',
  'FriendlyName' => '',
  'MessagingServiceSid' => '',
  'State' => '',
  'Timers.Closed' => '',
  'Timers.Inactive' => '',
  'UniqueName' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Attributes' => '',
  'DateCreated' => '',
  'DateUpdated' => '',
  'FriendlyName' => '',
  'MessagingServiceSid' => '',
  'State' => '',
  'Timers.Closed' => '',
  'Timers.Inactive' => '',
  'UniqueName' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Conversations/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Conversations/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations/:Sid"

payload = {
    "Attributes": "",
    "DateCreated": "",
    "DateUpdated": "",
    "FriendlyName": "",
    "MessagingServiceSid": "",
    "State": "",
    "Timers.Closed": "",
    "Timers.Inactive": "",
    "UniqueName": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations/:Sid"

payload <- "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Attributes => "",
  :DateCreated => "",
  :DateUpdated => "",
  :FriendlyName => "",
  :MessagingServiceSid => "",
  :State => "",
  :Timers.Closed => "",
  :Timers.Inactive => "",
  :UniqueName => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Conversations/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations/:Sid";

    let payload = json!({
        "Attributes": "",
        "DateCreated": "",
        "DateUpdated": "",
        "FriendlyName": "",
        "MessagingServiceSid": "",
        "State": "",
        "Timers.Closed": "",
        "Timers.Inactive": "",
        "UniqueName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Conversations/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data DateCreated= \
  --data DateUpdated= \
  --data FriendlyName= \
  --data MessagingServiceSid= \
  --data State= \
  --data Timers.Closed= \
  --data Timers.Inactive= \
  --data UniqueName=

http --form POST {{baseUrl}}/v1/Conversations/:Sid \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  DateCreated='' \
  DateUpdated='' \
  FriendlyName='' \
  MessagingServiceSid='' \
  State='' \
  Timers.Closed='' \
  Timers.Inactive='' \
  UniqueName=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=' \
  --output-document \
  - {{baseUrl}}/v1/Conversations/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&DateCreated=".data(using: String.Encoding.utf8)!)
postData.append("&DateUpdated=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&MessagingServiceSid=".data(using: String.Encoding.utf8)!)
postData.append("&State=".data(using: String.Encoding.utf8)!)
postData.append("&Timers.Closed=".data(using: String.Encoding.utf8)!)
postData.append("&Timers.Inactive=".data(using: String.Encoding.utf8)!)
postData.append("&UniqueName=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateConversationMessage

{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid

QUERY PARAMS

ConversationSid

Sid

BODY formUrlEncoded

Attributes

Author

Body

DateCreated

DateUpdated

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Attributes=&Author=&Body=&DateCreated=&DateUpdated=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid" {:form-params {:Attributes ""
                                                                                                          :Author ""
                                                                                                          :Body ""
                                                                                                          :DateCreated ""
                                                                                                          :DateUpdated ""}})

require "http/client"

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&Author=&Body=&DateCreated=&DateUpdated="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "Author", "" },
        { "Body", "" },
        { "DateCreated", "" },
        { "DateUpdated", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&Author=&Body=&DateCreated=&DateUpdated=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"

	payload := strings.NewReader("Attributes=&Author=&Body=&DateCreated=&DateUpdated=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Conversations/:ConversationSid/Messages/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 51

Attributes=&Author=&Body=&DateCreated=&DateUpdated=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Attributes=&Author=&Body=&DateCreated=&DateUpdated=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&Author=&Body=&DateCreated=&DateUpdated="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Attributes=&Author=&Body=&DateCreated=&DateUpdated=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&Author=&Body=&DateCreated=&DateUpdated=")
  .asString();

const data = 'Attributes=&Author=&Body=&DateCreated=&DateUpdated=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('Author', '');
encodedParams.set('Body', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Attributes: '', Author: '', Body: '', DateCreated: '', DateUpdated: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    Author: '',
    Body: '',
    DateCreated: '',
    DateUpdated: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Attributes=&Author=&Body=&DateCreated=&DateUpdated=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations/:ConversationSid/Messages/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({Attributes: '', Author: '', Body: '', DateCreated: '', DateUpdated: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Attributes: '', Author: '', Body: '', DateCreated: '', DateUpdated: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Attributes: '',
  Author: '',
  Body: '',
  DateCreated: '',
  DateUpdated: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('Author', '');
encodedParams.set('Body', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('Author', '');
encodedParams.set('Body', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Author=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Body=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateCreated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateUpdated=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&Author=&Body=&DateCreated=&DateUpdated=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Attributes=&Author=&Body=&DateCreated=&DateUpdated=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid', [
  'form_params' => [
    'Attributes' => '',
    'Author' => '',
    'Body' => '',
    'DateCreated' => '',
    'DateUpdated' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Attributes' => '',
  'Author' => '',
  'Body' => '',
  'DateCreated' => '',
  'DateUpdated' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Attributes' => '',
  'Author' => '',
  'Body' => '',
  'DateCreated' => '',
  'DateUpdated' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&Author=&Body=&DateCreated=&DateUpdated='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&Author=&Body=&DateCreated=&DateUpdated='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Attributes=&Author=&Body=&DateCreated=&DateUpdated="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Conversations/:ConversationSid/Messages/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"

payload = {
    "Attributes": "",
    "Author": "",
    "Body": "",
    "DateCreated": "",
    "DateUpdated": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid"

payload <- "Attributes=&Author=&Body=&DateCreated=&DateUpdated="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Attributes=&Author=&Body=&DateCreated=&DateUpdated="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Attributes => "",
  :Author => "",
  :Body => "",
  :DateCreated => "",
  :DateUpdated => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Conversations/:ConversationSid/Messages/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid";

    let payload = json!({
        "Attributes": "",
        "Author": "",
        "Body": "",
        "DateCreated": "",
        "DateUpdated": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data Author= \
  --data Body= \
  --data DateCreated= \
  --data DateUpdated=

http --form POST {{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  Author='' \
  Body='' \
  DateCreated='' \
  DateUpdated=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&Author=&Body=&DateCreated=&DateUpdated=' \
  --output-document \
  - {{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&Author=".data(using: String.Encoding.utf8)!)
postData.append("&Body=".data(using: String.Encoding.utf8)!)
postData.append("&DateCreated=".data(using: String.Encoding.utf8)!)
postData.append("&DateUpdated=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations/:ConversationSid/Messages/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateConversationParticipant

{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid

QUERY PARAMS

ConversationSid

Sid

BODY formUrlEncoded

Attributes

DateCreated

DateUpdated

Identity

LastReadMessageIndex

LastReadTimestamp

MessagingBinding.ProjectedAddress

MessagingBinding.ProxyAddress

RoleSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid" {:form-params {:Attributes ""
                                                                                                              :DateCreated ""
                                                                                                              :DateUpdated ""
                                                                                                              :Identity ""
                                                                                                              :LastReadMessageIndex ""
                                                                                                              :LastReadTimestamp ""
                                                                                                              :MessagingBinding.ProjectedAddress ""
                                                                                                              :MessagingBinding.ProxyAddress ""
                                                                                                              :RoleSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "DateCreated", "" },
        { "DateUpdated", "" },
        { "Identity", "" },
        { "LastReadMessageIndex", "" },
        { "LastReadTimestamp", "" },
        { "MessagingBinding.ProjectedAddress", "" },
        { "MessagingBinding.ProxyAddress", "" },
        { "RoleSid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"

	payload := strings.NewReader("Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Conversations/:ConversationSid/Participants/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 163

Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=")
  .asString();

const data = 'Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('Identity', '');
encodedParams.set('LastReadMessageIndex', '');
encodedParams.set('LastReadTimestamp', '');
encodedParams.set('MessagingBinding.ProjectedAddress', '');
encodedParams.set('MessagingBinding.ProxyAddress', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    Identity: '',
    LastReadMessageIndex: '',
    LastReadTimestamp: '',
    'MessagingBinding.ProjectedAddress': '',
    'MessagingBinding.ProxyAddress': '',
    RoleSid: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    Identity: '',
    LastReadMessageIndex: '',
    LastReadTimestamp: '',
    'MessagingBinding.ProjectedAddress': '',
    'MessagingBinding.ProxyAddress': '',
    RoleSid: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations/:ConversationSid/Participants/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  Attributes: '',
  DateCreated: '',
  DateUpdated: '',
  Identity: '',
  LastReadMessageIndex: '',
  LastReadTimestamp: '',
  'MessagingBinding.ProjectedAddress': '',
  'MessagingBinding.ProxyAddress': '',
  RoleSid: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    Identity: '',
    LastReadMessageIndex: '',
    LastReadTimestamp: '',
    'MessagingBinding.ProjectedAddress': '',
    'MessagingBinding.ProxyAddress': '',
    RoleSid: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Attributes: '',
  DateCreated: '',
  DateUpdated: '',
  Identity: '',
  LastReadMessageIndex: '',
  LastReadTimestamp: '',
  'MessagingBinding.ProjectedAddress': '',
  'MessagingBinding.ProxyAddress': '',
  RoleSid: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('Identity', '');
encodedParams.set('LastReadMessageIndex', '');
encodedParams.set('LastReadTimestamp', '');
encodedParams.set('MessagingBinding.ProjectedAddress', '');
encodedParams.set('MessagingBinding.ProxyAddress', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('Identity', '');
encodedParams.set('LastReadMessageIndex', '');
encodedParams.set('LastReadTimestamp', '');
encodedParams.set('MessagingBinding.ProjectedAddress', '');
encodedParams.set('MessagingBinding.ProxyAddress', '');
encodedParams.set('RoleSid', '');

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateCreated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateUpdated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Identity=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&LastReadMessageIndex=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&LastReadTimestamp=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MessagingBinding.ProjectedAddress=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MessagingBinding.ProxyAddress=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&RoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid', [
  'form_params' => [
    'Attributes' => '',
    'DateCreated' => '',
    'DateUpdated' => '',
    'Identity' => '',
    'LastReadMessageIndex' => '',
    'LastReadTimestamp' => '',
    'MessagingBinding.ProjectedAddress' => '',
    'MessagingBinding.ProxyAddress' => '',
    'RoleSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Attributes' => '',
  'DateCreated' => '',
  'DateUpdated' => '',
  'Identity' => '',
  'LastReadMessageIndex' => '',
  'LastReadTimestamp' => '',
  'MessagingBinding.ProjectedAddress' => '',
  'MessagingBinding.ProxyAddress' => '',
  'RoleSid' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Attributes' => '',
  'DateCreated' => '',
  'DateUpdated' => '',
  'Identity' => '',
  'LastReadMessageIndex' => '',
  'LastReadTimestamp' => '',
  'MessagingBinding.ProjectedAddress' => '',
  'MessagingBinding.ProxyAddress' => '',
  'RoleSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Conversations/:ConversationSid/Participants/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"

payload = {
    "Attributes": "",
    "DateCreated": "",
    "DateUpdated": "",
    "Identity": "",
    "LastReadMessageIndex": "",
    "LastReadTimestamp": "",
    "MessagingBinding.ProjectedAddress": "",
    "MessagingBinding.ProxyAddress": "",
    "RoleSid": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid"

payload <- "Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Attributes => "",
  :DateCreated => "",
  :DateUpdated => "",
  :Identity => "",
  :LastReadMessageIndex => "",
  :LastReadTimestamp => "",
  :MessagingBinding.ProjectedAddress => "",
  :MessagingBinding.ProxyAddress => "",
  :RoleSid => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Conversations/:ConversationSid/Participants/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid";

    let payload = json!({
        "Attributes": "",
        "DateCreated": "",
        "DateUpdated": "",
        "Identity": "",
        "LastReadMessageIndex": "",
        "LastReadTimestamp": "",
        "MessagingBinding.ProjectedAddress": "",
        "MessagingBinding.ProxyAddress": "",
        "RoleSid": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data DateCreated= \
  --data DateUpdated= \
  --data Identity= \
  --data LastReadMessageIndex= \
  --data LastReadTimestamp= \
  --data MessagingBinding.ProjectedAddress= \
  --data MessagingBinding.ProxyAddress= \
  --data RoleSid=

http --form POST {{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  DateCreated='' \
  DateUpdated='' \
  Identity='' \
  LastReadMessageIndex='' \
  LastReadTimestamp='' \
  MessagingBinding.ProjectedAddress='' \
  MessagingBinding.ProxyAddress='' \
  RoleSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=' \
  --output-document \
  - {{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&DateCreated=".data(using: String.Encoding.utf8)!)
postData.append("&DateUpdated=".data(using: String.Encoding.utf8)!)
postData.append("&Identity=".data(using: String.Encoding.utf8)!)
postData.append("&LastReadMessageIndex=".data(using: String.Encoding.utf8)!)
postData.append("&LastReadTimestamp=".data(using: String.Encoding.utf8)!)
postData.append("&MessagingBinding.ProjectedAddress=".data(using: String.Encoding.utf8)!)
postData.append("&MessagingBinding.ProxyAddress=".data(using: String.Encoding.utf8)!)
postData.append("&RoleSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations/:ConversationSid/Participants/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateConversationScopedWebhook

{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid

QUERY PARAMS

ConversationSid

Sid

BODY formUrlEncoded

Configuration.Filters

Configuration.FlowSid

Configuration.Method

Configuration.Triggers

Configuration.Url

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid" {:form-params {:Configuration.Filters ""
                                                                                                          :Configuration.FlowSid ""
                                                                                                          :Configuration.Method ""
                                                                                                          :Configuration.Triggers ""
                                                                                                          :Configuration.Url ""}})

require "http/client"

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Configuration.Filters", "" },
        { "Configuration.FlowSid", "" },
        { "Configuration.Method", "" },
        { "Configuration.Triggers", "" },
        { "Configuration.Url", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"

	payload := strings.NewReader("Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Conversations/:ConversationSid/Webhooks/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 110

Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=")
  .asString();

const data = 'Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Configuration.Filters', '');
encodedParams.set('Configuration.FlowSid', '');
encodedParams.set('Configuration.Method', '');
encodedParams.set('Configuration.Triggers', '');
encodedParams.set('Configuration.Url', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    'Configuration.Filters': '',
    'Configuration.FlowSid': '',
    'Configuration.Method': '',
    'Configuration.Triggers': '',
    'Configuration.Url': ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    'Configuration.Filters': '',
    'Configuration.FlowSid': '',
    'Configuration.Method': '',
    'Configuration.Triggers': '',
    'Configuration.Url': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Conversations/:ConversationSid/Webhooks/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  'Configuration.Filters': '',
  'Configuration.FlowSid': '',
  'Configuration.Method': '',
  'Configuration.Triggers': '',
  'Configuration.Url': ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    'Configuration.Filters': '',
    'Configuration.FlowSid': '',
    'Configuration.Method': '',
    'Configuration.Triggers': '',
    'Configuration.Url': ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  'Configuration.Filters': '',
  'Configuration.FlowSid': '',
  'Configuration.Method': '',
  'Configuration.Triggers': '',
  'Configuration.Url': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Configuration.Filters', '');
encodedParams.set('Configuration.FlowSid', '');
encodedParams.set('Configuration.Method', '');
encodedParams.set('Configuration.Triggers', '');
encodedParams.set('Configuration.Url', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Configuration.Filters', '');
encodedParams.set('Configuration.FlowSid', '');
encodedParams.set('Configuration.Method', '');
encodedParams.set('Configuration.Triggers', '');
encodedParams.set('Configuration.Url', '');

const url = '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Configuration.Filters=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Configuration.FlowSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Configuration.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Configuration.Triggers=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Configuration.Url=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid', [
  'form_params' => [
    'Configuration.Filters' => '',
    'Configuration.FlowSid' => '',
    'Configuration.Method' => '',
    'Configuration.Triggers' => '',
    'Configuration.Url' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Configuration.Filters' => '',
  'Configuration.FlowSid' => '',
  'Configuration.Method' => '',
  'Configuration.Triggers' => '',
  'Configuration.Url' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Configuration.Filters' => '',
  'Configuration.FlowSid' => '',
  'Configuration.Method' => '',
  'Configuration.Triggers' => '',
  'Configuration.Url' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Conversations/:ConversationSid/Webhooks/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"

payload = {
    "Configuration.Filters": "",
    "Configuration.FlowSid": "",
    "Configuration.Method": "",
    "Configuration.Triggers": "",
    "Configuration.Url": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid"

payload <- "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Configuration.Filters => "",
  :Configuration.FlowSid => "",
  :Configuration.Method => "",
  :Configuration.Triggers => "",
  :Configuration.Url => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Conversations/:ConversationSid/Webhooks/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid";

    let payload = json!({
        "Configuration.Filters": "",
        "Configuration.FlowSid": "",
        "Configuration.Method": "",
        "Configuration.Triggers": "",
        "Configuration.Url": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Configuration.Filters= \
  --data Configuration.FlowSid= \
  --data Configuration.Method= \
  --data Configuration.Triggers= \
  --data Configuration.Url=

http --form POST {{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid \
  content-type:application/x-www-form-urlencoded \
  Configuration.Filters='' \
  Configuration.FlowSid='' \
  Configuration.Method='' \
  Configuration.Triggers='' \
  Configuration.Url=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=' \
  --output-document \
  - {{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Configuration.Filters=".data(using: String.Encoding.utf8)!)
postData.append("&Configuration.FlowSid=".data(using: String.Encoding.utf8)!)
postData.append("&Configuration.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Configuration.Triggers=".data(using: String.Encoding.utf8)!)
postData.append("&Configuration.Url=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Conversations/:ConversationSid/Webhooks/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateCredential

{{baseUrl}}/v1/Credentials/:Sid

QUERY PARAMS

Sid

BODY formUrlEncoded

ApiKey

Certificate

FriendlyName

PrivateKey

Sandbox

Secret

Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Credentials/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Credentials/:Sid" {:form-params {:ApiKey ""
                                                                              :Certificate ""
                                                                              :FriendlyName ""
                                                                              :PrivateKey ""
                                                                              :Sandbox ""
                                                                              :Secret ""
                                                                              :Type ""}})

require "http/client"

url = "{{baseUrl}}/v1/Credentials/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Credentials/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "ApiKey", "" },
        { "Certificate", "" },
        { "FriendlyName", "" },
        { "PrivateKey", "" },
        { "Sandbox", "" },
        { "Secret", "" },
        { "Type", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Credentials/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Credentials/:Sid"

	payload := strings.NewReader("ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Credentials/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 69

ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Credentials/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Credentials/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Credentials/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Credentials/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=")
  .asString();

const data = 'ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Credentials/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('ApiKey', '');
encodedParams.set('Certificate', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('PrivateKey', '');
encodedParams.set('Sandbox', '');
encodedParams.set('Secret', '');
encodedParams.set('Type', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Credentials/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Credentials/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    ApiKey: '',
    Certificate: '',
    FriendlyName: '',
    PrivateKey: '',
    Sandbox: '',
    Secret: '',
    Type: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Credentials/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    ApiKey: '',
    Certificate: '',
    FriendlyName: '',
    PrivateKey: '',
    Sandbox: '',
    Secret: '',
    Type: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Credentials/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Credentials/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  ApiKey: '',
  Certificate: '',
  FriendlyName: '',
  PrivateKey: '',
  Sandbox: '',
  Secret: '',
  Type: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Credentials/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    ApiKey: '',
    Certificate: '',
    FriendlyName: '',
    PrivateKey: '',
    Sandbox: '',
    Secret: '',
    Type: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Credentials/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  ApiKey: '',
  Certificate: '',
  FriendlyName: '',
  PrivateKey: '',
  Sandbox: '',
  Secret: '',
  Type: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('ApiKey', '');
encodedParams.set('Certificate', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('PrivateKey', '');
encodedParams.set('Sandbox', '');
encodedParams.set('Secret', '');
encodedParams.set('Type', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Credentials/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('ApiKey', '');
encodedParams.set('Certificate', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('PrivateKey', '');
encodedParams.set('Sandbox', '');
encodedParams.set('Secret', '');
encodedParams.set('Type', '');

const url = '{{baseUrl}}/v1/Credentials/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"ApiKey=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Certificate=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&PrivateKey=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Sandbox=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Secret=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Type=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Credentials/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Credentials/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Credentials/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Credentials/:Sid', [
  'form_params' => [
    'ApiKey' => '',
    'Certificate' => '',
    'FriendlyName' => '',
    'PrivateKey' => '',
    'Sandbox' => '',
    'Secret' => '',
    'Type' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Credentials/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'ApiKey' => '',
  'Certificate' => '',
  'FriendlyName' => '',
  'PrivateKey' => '',
  'Sandbox' => '',
  'Secret' => '',
  'Type' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'ApiKey' => '',
  'Certificate' => '',
  'FriendlyName' => '',
  'PrivateKey' => '',
  'Sandbox' => '',
  'Secret' => '',
  'Type' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Credentials/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Credentials/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Credentials/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Credentials/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Credentials/:Sid"

payload = {
    "ApiKey": "",
    "Certificate": "",
    "FriendlyName": "",
    "PrivateKey": "",
    "Sandbox": "",
    "Secret": "",
    "Type": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Credentials/:Sid"

payload <- "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Credentials/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :ApiKey => "",
  :Certificate => "",
  :FriendlyName => "",
  :PrivateKey => "",
  :Sandbox => "",
  :Secret => "",
  :Type => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Credentials/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Credentials/:Sid";

    let payload = json!({
        "ApiKey": "",
        "Certificate": "",
        "FriendlyName": "",
        "PrivateKey": "",
        "Sandbox": "",
        "Secret": "",
        "Type": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Credentials/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data ApiKey= \
  --data Certificate= \
  --data FriendlyName= \
  --data PrivateKey= \
  --data Sandbox= \
  --data Secret= \
  --data Type=

http --form POST {{baseUrl}}/v1/Credentials/:Sid \
  content-type:application/x-www-form-urlencoded \
  ApiKey='' \
  Certificate='' \
  FriendlyName='' \
  PrivateKey='' \
  Sandbox='' \
  Secret='' \
  Type=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=&Type=' \
  --output-document \
  - {{baseUrl}}/v1/Credentials/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "ApiKey=".data(using: String.Encoding.utf8)!)
postData.append("&Certificate=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&PrivateKey=".data(using: String.Encoding.utf8)!)
postData.append("&Sandbox=".data(using: String.Encoding.utf8)!)
postData.append("&Secret=".data(using: String.Encoding.utf8)!)
postData.append("&Type=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Credentials/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateRole

{{baseUrl}}/v1/Roles/:Sid

QUERY PARAMS

Sid

BODY formUrlEncoded

Permission

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Roles/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Permission=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Roles/:Sid" {:form-params {:Permission ""}})

require "http/client"

url = "{{baseUrl}}/v1/Roles/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Permission="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Roles/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Permission", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Roles/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Permission=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Roles/:Sid"

	payload := strings.NewReader("Permission=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Roles/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 11

Permission=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Roles/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Permission=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Roles/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Permission="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Permission=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Roles/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Roles/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Permission=")
  .asString();

const data = 'Permission=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Roles/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Permission', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Roles/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Roles/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Permission: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Roles/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Permission: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Permission=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Roles/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Roles/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({Permission: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Roles/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Permission: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Roles/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Permission: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Permission', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Roles/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Permission', '');

const url = '{{baseUrl}}/v1/Roles/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Permission=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Roles/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Roles/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Permission=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Roles/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Permission=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Roles/:Sid', [
  'form_params' => [
    'Permission' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Roles/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Permission' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Permission' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Roles/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Roles/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Permission='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Roles/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Permission='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Permission="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Roles/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Roles/:Sid"

payload = { "Permission": "" }
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Roles/:Sid"

payload <- "Permission="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Roles/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Permission="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Permission => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Roles/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Roles/:Sid";

    let payload = json!({"Permission": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Roles/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Permission=

http --form POST {{baseUrl}}/v1/Roles/:Sid \
  content-type:application/x-www-form-urlencoded \
  Permission=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data Permission= \
  --output-document \
  - {{baseUrl}}/v1/Roles/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Permission=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Roles/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateServiceConfiguration

{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration

QUERY PARAMS

ChatServiceSid

BODY formUrlEncoded

DefaultChatServiceRoleSid

DefaultConversationCreatorRoleSid

DefaultConversationRoleSid

ReachabilityEnabled

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "DefaultChatServiceRoleSid=&DefaultConversationCreatorRoleSid=&DefaultConversationRoleSid=&ReachabilityEnabled=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration" {:form-params {:DefaultChatServiceRoleSid ""
                                                                                                    :DefaultConversationCreatorRoleSid ""
                                                                                                    :DefaultConversationRoleSid ""
                                                                                                    :ReachabilityEnabled ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "DefaultChatServiceRoleSid=&DefaultConversationCreatorRoleSid=&DefaultConversationRoleSid=&ReachabilityEnabled="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "DefaultChatServiceRoleSid", "" },
        { "DefaultConversationCreatorRoleSid", "" },
        { "DefaultConversationRoleSid", "" },
        { "ReachabilityEnabled", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "DefaultChatServiceRoleSid=&DefaultConversationCreatorRoleSid=&DefaultConversationRoleSid=&ReachabilityEnabled=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration"

	payload := strings.NewReader("DefaultChatServiceRoleSid=&DefaultConversationCreatorRoleSid=&DefaultConversationRoleSid=&ReachabilityEnabled=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Services/:ChatServiceSid/Configuration HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 110

DefaultChatServiceRoleSid=&DefaultConversationCreatorRoleSid=&DefaultConversationRoleSid=&ReachabilityEnabled=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("DefaultChatServiceRoleSid=&DefaultConversationCreatorRoleSid=&DefaultConversationRoleSid=&ReachabilityEnabled=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("DefaultChatServiceRoleSid=&DefaultConversationCreatorRoleSid=&DefaultConversationRoleSid=&ReachabilityEnabled="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "DefaultChatServiceRoleSid=&DefaultConversationCreatorRoleSid=&DefaultConversationRoleSid=&ReachabilityEnabled=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("DefaultChatServiceRoleSid=&DefaultConversationCreatorRoleSid=&DefaultConversationRoleSid=&ReachabilityEnabled=")
  .asString();

const data = 'DefaultChatServiceRoleSid=&DefaultConversationCreatorRoleSid=&DefaultConversationRoleSid=&ReachabilityEnabled=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('DefaultChatServiceRoleSid', '');
encodedParams.set('DefaultConversationCreatorRoleSid', '');
encodedParams.set('DefaultConversationRoleSid', '');
encodedParams.set('ReachabilityEnabled', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    DefaultChatServiceRoleSid: '',
    DefaultConversationCreatorRoleSid: '',
    DefaultConversationRoleSid: '',
    ReachabilityEnabled: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    DefaultChatServiceRoleSid: '',
    DefaultConversationCreatorRoleSid: '',
    DefaultConversationRoleSid: '',
    ReachabilityEnabled: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "DefaultChatServiceRoleSid=&DefaultConversationCreatorRoleSid=&DefaultConversationRoleSid=&ReachabilityEnabled=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Configuration',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  DefaultChatServiceRoleSid: '',
  DefaultConversationCreatorRoleSid: '',
  DefaultConversationRoleSid: '',
  ReachabilityEnabled: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    DefaultChatServiceRoleSid: '',
    DefaultConversationCreatorRoleSid: '',
    DefaultConversationRoleSid: '',
    ReachabilityEnabled: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  DefaultChatServiceRoleSid: '',
  DefaultConversationCreatorRoleSid: '',
  DefaultConversationRoleSid: '',
  ReachabilityEnabled: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('DefaultChatServiceRoleSid', '');
encodedParams.set('DefaultConversationCreatorRoleSid', '');
encodedParams.set('DefaultConversationRoleSid', '');
encodedParams.set('ReachabilityEnabled', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('DefaultChatServiceRoleSid', '');
encodedParams.set('DefaultConversationCreatorRoleSid', '');
encodedParams.set('DefaultConversationRoleSid', '');
encodedParams.set('ReachabilityEnabled', '');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"DefaultChatServiceRoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DefaultConversationCreatorRoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DefaultConversationRoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ReachabilityEnabled=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "DefaultChatServiceRoleSid=&DefaultConversationCreatorRoleSid=&DefaultConversationRoleSid=&ReachabilityEnabled=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "DefaultChatServiceRoleSid=&DefaultConversationCreatorRoleSid=&DefaultConversationRoleSid=&ReachabilityEnabled=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration', [
  'form_params' => [
    'DefaultChatServiceRoleSid' => '',
    'DefaultConversationCreatorRoleSid' => '',
    'DefaultConversationRoleSid' => '',
    'ReachabilityEnabled' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'DefaultChatServiceRoleSid' => '',
  'DefaultConversationCreatorRoleSid' => '',
  'DefaultConversationRoleSid' => '',
  'ReachabilityEnabled' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'DefaultChatServiceRoleSid' => '',
  'DefaultConversationCreatorRoleSid' => '',
  'DefaultConversationRoleSid' => '',
  'ReachabilityEnabled' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'DefaultChatServiceRoleSid=&DefaultConversationCreatorRoleSid=&DefaultConversationRoleSid=&ReachabilityEnabled='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'DefaultChatServiceRoleSid=&DefaultConversationCreatorRoleSid=&DefaultConversationRoleSid=&ReachabilityEnabled='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "DefaultChatServiceRoleSid=&DefaultConversationCreatorRoleSid=&DefaultConversationRoleSid=&ReachabilityEnabled="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ChatServiceSid/Configuration", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration"

payload = {
    "DefaultChatServiceRoleSid": "",
    "DefaultConversationCreatorRoleSid": "",
    "DefaultConversationRoleSid": "",
    "ReachabilityEnabled": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration"

payload <- "DefaultChatServiceRoleSid=&DefaultConversationCreatorRoleSid=&DefaultConversationRoleSid=&ReachabilityEnabled="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "DefaultChatServiceRoleSid=&DefaultConversationCreatorRoleSid=&DefaultConversationRoleSid=&ReachabilityEnabled="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :DefaultChatServiceRoleSid => "",
  :DefaultConversationCreatorRoleSid => "",
  :DefaultConversationRoleSid => "",
  :ReachabilityEnabled => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ChatServiceSid/Configuration') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration";

    let payload = json!({
        "DefaultChatServiceRoleSid": "",
        "DefaultConversationCreatorRoleSid": "",
        "DefaultConversationRoleSid": "",
        "ReachabilityEnabled": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Configuration \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data DefaultChatServiceRoleSid= \
  --data DefaultConversationCreatorRoleSid= \
  --data DefaultConversationRoleSid= \
  --data ReachabilityEnabled=

http --form POST {{baseUrl}}/v1/Services/:ChatServiceSid/Configuration \
  content-type:application/x-www-form-urlencoded \
  DefaultChatServiceRoleSid='' \
  DefaultConversationCreatorRoleSid='' \
  DefaultConversationRoleSid='' \
  ReachabilityEnabled=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'DefaultChatServiceRoleSid=&DefaultConversationCreatorRoleSid=&DefaultConversationRoleSid=&ReachabilityEnabled=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Configuration

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "DefaultChatServiceRoleSid=".data(using: String.Encoding.utf8)!)
postData.append("&DefaultConversationCreatorRoleSid=".data(using: String.Encoding.utf8)!)
postData.append("&DefaultConversationRoleSid=".data(using: String.Encoding.utf8)!)
postData.append("&ReachabilityEnabled=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateServiceConversation

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid

QUERY PARAMS

ChatServiceSid

Sid

BODY formUrlEncoded

Attributes

DateCreated

DateUpdated

FriendlyName

MessagingServiceSid

State

Timers.Closed

Timers.Inactive

UniqueName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid" {:form-params {:Attributes ""
                                                                                                         :DateCreated ""
                                                                                                         :DateUpdated ""
                                                                                                         :FriendlyName ""
                                                                                                         :MessagingServiceSid ""
                                                                                                         :State ""
                                                                                                         :Timers.Closed ""
                                                                                                         :Timers.Inactive ""
                                                                                                         :UniqueName ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "DateCreated", "" },
        { "DateUpdated", "" },
        { "FriendlyName", "" },
        { "MessagingServiceSid", "" },
        { "State", "" },
        { "Timers.Closed", "" },
        { "Timers.Inactive", "" },
        { "UniqueName", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"

	payload := strings.NewReader("Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Services/:ChatServiceSid/Conversations/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 123

Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=")
  .asString();

const data = 'Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('MessagingServiceSid', '');
encodedParams.set('State', '');
encodedParams.set('Timers.Closed', '');
encodedParams.set('Timers.Inactive', '');
encodedParams.set('UniqueName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    FriendlyName: '',
    MessagingServiceSid: '',
    State: '',
    'Timers.Closed': '',
    'Timers.Inactive': '',
    UniqueName: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    FriendlyName: '',
    MessagingServiceSid: '',
    State: '',
    'Timers.Closed': '',
    'Timers.Inactive': '',
    UniqueName: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  Attributes: '',
  DateCreated: '',
  DateUpdated: '',
  FriendlyName: '',
  MessagingServiceSid: '',
  State: '',
  'Timers.Closed': '',
  'Timers.Inactive': '',
  UniqueName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    FriendlyName: '',
    MessagingServiceSid: '',
    State: '',
    'Timers.Closed': '',
    'Timers.Inactive': '',
    UniqueName: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Attributes: '',
  DateCreated: '',
  DateUpdated: '',
  FriendlyName: '',
  MessagingServiceSid: '',
  State: '',
  'Timers.Closed': '',
  'Timers.Inactive': '',
  UniqueName: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('MessagingServiceSid', '');
encodedParams.set('State', '');
encodedParams.set('Timers.Closed', '');
encodedParams.set('Timers.Inactive', '');
encodedParams.set('UniqueName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('MessagingServiceSid', '');
encodedParams.set('State', '');
encodedParams.set('Timers.Closed', '');
encodedParams.set('Timers.Inactive', '');
encodedParams.set('UniqueName', '');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateCreated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateUpdated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MessagingServiceSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&State=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Timers.Closed=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Timers.Inactive=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UniqueName=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid', [
  'form_params' => [
    'Attributes' => '',
    'DateCreated' => '',
    'DateUpdated' => '',
    'FriendlyName' => '',
    'MessagingServiceSid' => '',
    'State' => '',
    'Timers.Closed' => '',
    'Timers.Inactive' => '',
    'UniqueName' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Attributes' => '',
  'DateCreated' => '',
  'DateUpdated' => '',
  'FriendlyName' => '',
  'MessagingServiceSid' => '',
  'State' => '',
  'Timers.Closed' => '',
  'Timers.Inactive' => '',
  'UniqueName' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Attributes' => '',
  'DateCreated' => '',
  'DateUpdated' => '',
  'FriendlyName' => '',
  'MessagingServiceSid' => '',
  'State' => '',
  'Timers.Closed' => '',
  'Timers.Inactive' => '',
  'UniqueName' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ChatServiceSid/Conversations/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"

payload = {
    "Attributes": "",
    "DateCreated": "",
    "DateUpdated": "",
    "FriendlyName": "",
    "MessagingServiceSid": "",
    "State": "",
    "Timers.Closed": "",
    "Timers.Inactive": "",
    "UniqueName": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid"

payload <- "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Attributes => "",
  :DateCreated => "",
  :DateUpdated => "",
  :FriendlyName => "",
  :MessagingServiceSid => "",
  :State => "",
  :Timers.Closed => "",
  :Timers.Inactive => "",
  :UniqueName => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ChatServiceSid/Conversations/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid";

    let payload = json!({
        "Attributes": "",
        "DateCreated": "",
        "DateUpdated": "",
        "FriendlyName": "",
        "MessagingServiceSid": "",
        "State": "",
        "Timers.Closed": "",
        "Timers.Inactive": "",
        "UniqueName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data DateCreated= \
  --data DateUpdated= \
  --data FriendlyName= \
  --data MessagingServiceSid= \
  --data State= \
  --data Timers.Closed= \
  --data Timers.Inactive= \
  --data UniqueName=

http --form POST {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  DateCreated='' \
  DateUpdated='' \
  FriendlyName='' \
  MessagingServiceSid='' \
  State='' \
  Timers.Closed='' \
  Timers.Inactive='' \
  UniqueName=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&DateCreated=&DateUpdated=&FriendlyName=&MessagingServiceSid=&State=&Timers.Closed=&Timers.Inactive=&UniqueName=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&DateCreated=".data(using: String.Encoding.utf8)!)
postData.append("&DateUpdated=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&MessagingServiceSid=".data(using: String.Encoding.utf8)!)
postData.append("&State=".data(using: String.Encoding.utf8)!)
postData.append("&Timers.Closed=".data(using: String.Encoding.utf8)!)
postData.append("&Timers.Inactive=".data(using: String.Encoding.utf8)!)
postData.append("&UniqueName=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateServiceConversationMessage

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid

QUERY PARAMS

ChatServiceSid

ConversationSid

Sid

BODY formUrlEncoded

Attributes

Author

Body

DateCreated

DateUpdated

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Attributes=&Author=&Body=&DateCreated=&DateUpdated=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid" {:form-params {:Attributes ""
                                                                                                                                   :Author ""
                                                                                                                                   :Body ""
                                                                                                                                   :DateCreated ""
                                                                                                                                   :DateUpdated ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&Author=&Body=&DateCreated=&DateUpdated="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "Author", "" },
        { "Body", "" },
        { "DateCreated", "" },
        { "DateUpdated", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&Author=&Body=&DateCreated=&DateUpdated=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"

	payload := strings.NewReader("Attributes=&Author=&Body=&DateCreated=&DateUpdated=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 51

Attributes=&Author=&Body=&DateCreated=&DateUpdated=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Attributes=&Author=&Body=&DateCreated=&DateUpdated=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&Author=&Body=&DateCreated=&DateUpdated="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Attributes=&Author=&Body=&DateCreated=&DateUpdated=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&Author=&Body=&DateCreated=&DateUpdated=")
  .asString();

const data = 'Attributes=&Author=&Body=&DateCreated=&DateUpdated=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('Author', '');
encodedParams.set('Body', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Attributes: '', Author: '', Body: '', DateCreated: '', DateUpdated: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    Author: '',
    Body: '',
    DateCreated: '',
    DateUpdated: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Attributes=&Author=&Body=&DateCreated=&DateUpdated=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({Attributes: '', Author: '', Body: '', DateCreated: '', DateUpdated: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Attributes: '', Author: '', Body: '', DateCreated: '', DateUpdated: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Attributes: '',
  Author: '',
  Body: '',
  DateCreated: '',
  DateUpdated: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('Author', '');
encodedParams.set('Body', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('Author', '');
encodedParams.set('Body', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Author=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Body=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateCreated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateUpdated=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&Author=&Body=&DateCreated=&DateUpdated=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Attributes=&Author=&Body=&DateCreated=&DateUpdated=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid', [
  'form_params' => [
    'Attributes' => '',
    'Author' => '',
    'Body' => '',
    'DateCreated' => '',
    'DateUpdated' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Attributes' => '',
  'Author' => '',
  'Body' => '',
  'DateCreated' => '',
  'DateUpdated' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Attributes' => '',
  'Author' => '',
  'Body' => '',
  'DateCreated' => '',
  'DateUpdated' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&Author=&Body=&DateCreated=&DateUpdated='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&Author=&Body=&DateCreated=&DateUpdated='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Attributes=&Author=&Body=&DateCreated=&DateUpdated="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"

payload = {
    "Attributes": "",
    "Author": "",
    "Body": "",
    "DateCreated": "",
    "DateUpdated": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid"

payload <- "Attributes=&Author=&Body=&DateCreated=&DateUpdated="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Attributes=&Author=&Body=&DateCreated=&DateUpdated="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Attributes => "",
  :Author => "",
  :Body => "",
  :DateCreated => "",
  :DateUpdated => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid";

    let payload = json!({
        "Attributes": "",
        "Author": "",
        "Body": "",
        "DateCreated": "",
        "DateUpdated": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data Author= \
  --data Body= \
  --data DateCreated= \
  --data DateUpdated=

http --form POST {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  Author='' \
  Body='' \
  DateCreated='' \
  DateUpdated=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&Author=&Body=&DateCreated=&DateUpdated=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&Author=".data(using: String.Encoding.utf8)!)
postData.append("&Body=".data(using: String.Encoding.utf8)!)
postData.append("&DateCreated=".data(using: String.Encoding.utf8)!)
postData.append("&DateUpdated=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Messages/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateServiceConversationParticipant

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid

QUERY PARAMS

ChatServiceSid

ConversationSid

Sid

BODY formUrlEncoded

Attributes

DateCreated

DateUpdated

Identity

LastReadMessageIndex

LastReadTimestamp

MessagingBinding.ProjectedAddress

MessagingBinding.ProxyAddress

RoleSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid" {:form-params {:Attributes ""
                                                                                                                                       :DateCreated ""
                                                                                                                                       :DateUpdated ""
                                                                                                                                       :Identity ""
                                                                                                                                       :LastReadMessageIndex ""
                                                                                                                                       :LastReadTimestamp ""
                                                                                                                                       :MessagingBinding.ProjectedAddress ""
                                                                                                                                       :MessagingBinding.ProxyAddress ""
                                                                                                                                       :RoleSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "DateCreated", "" },
        { "DateUpdated", "" },
        { "Identity", "" },
        { "LastReadMessageIndex", "" },
        { "LastReadTimestamp", "" },
        { "MessagingBinding.ProjectedAddress", "" },
        { "MessagingBinding.ProxyAddress", "" },
        { "RoleSid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"

	payload := strings.NewReader("Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 163

Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=")
  .asString();

const data = 'Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('Identity', '');
encodedParams.set('LastReadMessageIndex', '');
encodedParams.set('LastReadTimestamp', '');
encodedParams.set('MessagingBinding.ProjectedAddress', '');
encodedParams.set('MessagingBinding.ProxyAddress', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    Identity: '',
    LastReadMessageIndex: '',
    LastReadTimestamp: '',
    'MessagingBinding.ProjectedAddress': '',
    'MessagingBinding.ProxyAddress': '',
    RoleSid: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    Identity: '',
    LastReadMessageIndex: '',
    LastReadTimestamp: '',
    'MessagingBinding.ProjectedAddress': '',
    'MessagingBinding.ProxyAddress': '',
    RoleSid: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  Attributes: '',
  DateCreated: '',
  DateUpdated: '',
  Identity: '',
  LastReadMessageIndex: '',
  LastReadTimestamp: '',
  'MessagingBinding.ProjectedAddress': '',
  'MessagingBinding.ProxyAddress': '',
  RoleSid: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    Attributes: '',
    DateCreated: '',
    DateUpdated: '',
    Identity: '',
    LastReadMessageIndex: '',
    LastReadTimestamp: '',
    'MessagingBinding.ProjectedAddress': '',
    'MessagingBinding.ProxyAddress': '',
    RoleSid: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Attributes: '',
  DateCreated: '',
  DateUpdated: '',
  Identity: '',
  LastReadMessageIndex: '',
  LastReadTimestamp: '',
  'MessagingBinding.ProjectedAddress': '',
  'MessagingBinding.ProxyAddress': '',
  RoleSid: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('Identity', '');
encodedParams.set('LastReadMessageIndex', '');
encodedParams.set('LastReadTimestamp', '');
encodedParams.set('MessagingBinding.ProjectedAddress', '');
encodedParams.set('MessagingBinding.ProxyAddress', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('DateCreated', '');
encodedParams.set('DateUpdated', '');
encodedParams.set('Identity', '');
encodedParams.set('LastReadMessageIndex', '');
encodedParams.set('LastReadTimestamp', '');
encodedParams.set('MessagingBinding.ProjectedAddress', '');
encodedParams.set('MessagingBinding.ProxyAddress', '');
encodedParams.set('RoleSid', '');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateCreated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DateUpdated=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Identity=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&LastReadMessageIndex=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&LastReadTimestamp=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MessagingBinding.ProjectedAddress=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&MessagingBinding.ProxyAddress=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&RoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid', [
  'form_params' => [
    'Attributes' => '',
    'DateCreated' => '',
    'DateUpdated' => '',
    'Identity' => '',
    'LastReadMessageIndex' => '',
    'LastReadTimestamp' => '',
    'MessagingBinding.ProjectedAddress' => '',
    'MessagingBinding.ProxyAddress' => '',
    'RoleSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Attributes' => '',
  'DateCreated' => '',
  'DateUpdated' => '',
  'Identity' => '',
  'LastReadMessageIndex' => '',
  'LastReadTimestamp' => '',
  'MessagingBinding.ProjectedAddress' => '',
  'MessagingBinding.ProxyAddress' => '',
  'RoleSid' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Attributes' => '',
  'DateCreated' => '',
  'DateUpdated' => '',
  'Identity' => '',
  'LastReadMessageIndex' => '',
  'LastReadTimestamp' => '',
  'MessagingBinding.ProjectedAddress' => '',
  'MessagingBinding.ProxyAddress' => '',
  'RoleSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"

payload = {
    "Attributes": "",
    "DateCreated": "",
    "DateUpdated": "",
    "Identity": "",
    "LastReadMessageIndex": "",
    "LastReadTimestamp": "",
    "MessagingBinding.ProjectedAddress": "",
    "MessagingBinding.ProxyAddress": "",
    "RoleSid": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid"

payload <- "Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Attributes => "",
  :DateCreated => "",
  :DateUpdated => "",
  :Identity => "",
  :LastReadMessageIndex => "",
  :LastReadTimestamp => "",
  :MessagingBinding.ProjectedAddress => "",
  :MessagingBinding.ProxyAddress => "",
  :RoleSid => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid";

    let payload = json!({
        "Attributes": "",
        "DateCreated": "",
        "DateUpdated": "",
        "Identity": "",
        "LastReadMessageIndex": "",
        "LastReadTimestamp": "",
        "MessagingBinding.ProjectedAddress": "",
        "MessagingBinding.ProxyAddress": "",
        "RoleSid": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data DateCreated= \
  --data DateUpdated= \
  --data Identity= \
  --data LastReadMessageIndex= \
  --data LastReadTimestamp= \
  --data MessagingBinding.ProjectedAddress= \
  --data MessagingBinding.ProxyAddress= \
  --data RoleSid=

http --form POST {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  DateCreated='' \
  DateUpdated='' \
  Identity='' \
  LastReadMessageIndex='' \
  LastReadTimestamp='' \
  MessagingBinding.ProjectedAddress='' \
  MessagingBinding.ProxyAddress='' \
  RoleSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&DateCreated=&DateUpdated=&Identity=&LastReadMessageIndex=&LastReadTimestamp=&MessagingBinding.ProjectedAddress=&MessagingBinding.ProxyAddress=&RoleSid=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&DateCreated=".data(using: String.Encoding.utf8)!)
postData.append("&DateUpdated=".data(using: String.Encoding.utf8)!)
postData.append("&Identity=".data(using: String.Encoding.utf8)!)
postData.append("&LastReadMessageIndex=".data(using: String.Encoding.utf8)!)
postData.append("&LastReadTimestamp=".data(using: String.Encoding.utf8)!)
postData.append("&MessagingBinding.ProjectedAddress=".data(using: String.Encoding.utf8)!)
postData.append("&MessagingBinding.ProxyAddress=".data(using: String.Encoding.utf8)!)
postData.append("&RoleSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Participants/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateServiceConversationScopedWebhook

{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid

QUERY PARAMS

ChatServiceSid

ConversationSid

Sid

BODY formUrlEncoded

Configuration.Filters

Configuration.FlowSid

Configuration.Method

Configuration.Triggers

Configuration.Url

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid" {:form-params {:Configuration.Filters ""
                                                                                                                                   :Configuration.FlowSid ""
                                                                                                                                   :Configuration.Method ""
                                                                                                                                   :Configuration.Triggers ""
                                                                                                                                   :Configuration.Url ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Configuration.Filters", "" },
        { "Configuration.FlowSid", "" },
        { "Configuration.Method", "" },
        { "Configuration.Triggers", "" },
        { "Configuration.Url", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"

	payload := strings.NewReader("Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 110

Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=")
  .asString();

const data = 'Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Configuration.Filters', '');
encodedParams.set('Configuration.FlowSid', '');
encodedParams.set('Configuration.Method', '');
encodedParams.set('Configuration.Triggers', '');
encodedParams.set('Configuration.Url', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    'Configuration.Filters': '',
    'Configuration.FlowSid': '',
    'Configuration.Method': '',
    'Configuration.Triggers': '',
    'Configuration.Url': ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    'Configuration.Filters': '',
    'Configuration.FlowSid': '',
    'Configuration.Method': '',
    'Configuration.Triggers': '',
    'Configuration.Url': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  'Configuration.Filters': '',
  'Configuration.FlowSid': '',
  'Configuration.Method': '',
  'Configuration.Triggers': '',
  'Configuration.Url': ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    'Configuration.Filters': '',
    'Configuration.FlowSid': '',
    'Configuration.Method': '',
    'Configuration.Triggers': '',
    'Configuration.Url': ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  'Configuration.Filters': '',
  'Configuration.FlowSid': '',
  'Configuration.Method': '',
  'Configuration.Triggers': '',
  'Configuration.Url': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Configuration.Filters', '');
encodedParams.set('Configuration.FlowSid', '');
encodedParams.set('Configuration.Method', '');
encodedParams.set('Configuration.Triggers', '');
encodedParams.set('Configuration.Url', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Configuration.Filters', '');
encodedParams.set('Configuration.FlowSid', '');
encodedParams.set('Configuration.Method', '');
encodedParams.set('Configuration.Triggers', '');
encodedParams.set('Configuration.Url', '');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Configuration.Filters=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Configuration.FlowSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Configuration.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Configuration.Triggers=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Configuration.Url=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid', [
  'form_params' => [
    'Configuration.Filters' => '',
    'Configuration.FlowSid' => '',
    'Configuration.Method' => '',
    'Configuration.Triggers' => '',
    'Configuration.Url' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Configuration.Filters' => '',
  'Configuration.FlowSid' => '',
  'Configuration.Method' => '',
  'Configuration.Triggers' => '',
  'Configuration.Url' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Configuration.Filters' => '',
  'Configuration.FlowSid' => '',
  'Configuration.Method' => '',
  'Configuration.Triggers' => '',
  'Configuration.Url' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"

payload = {
    "Configuration.Filters": "",
    "Configuration.FlowSid": "",
    "Configuration.Method": "",
    "Configuration.Triggers": "",
    "Configuration.Url": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid"

payload <- "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Configuration.Filters => "",
  :Configuration.FlowSid => "",
  :Configuration.Method => "",
  :Configuration.Triggers => "",
  :Configuration.Url => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid";

    let payload = json!({
        "Configuration.Filters": "",
        "Configuration.FlowSid": "",
        "Configuration.Method": "",
        "Configuration.Triggers": "",
        "Configuration.Url": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Configuration.Filters= \
  --data Configuration.FlowSid= \
  --data Configuration.Method= \
  --data Configuration.Triggers= \
  --data Configuration.Url=

http --form POST {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid \
  content-type:application/x-www-form-urlencoded \
  Configuration.Filters='' \
  Configuration.FlowSid='' \
  Configuration.Method='' \
  Configuration.Triggers='' \
  Configuration.Url=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Configuration.Filters=&Configuration.FlowSid=&Configuration.Method=&Configuration.Triggers=&Configuration.Url=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Configuration.Filters=".data(using: String.Encoding.utf8)!)
postData.append("&Configuration.FlowSid=".data(using: String.Encoding.utf8)!)
postData.append("&Configuration.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Configuration.Triggers=".data(using: String.Encoding.utf8)!)
postData.append("&Configuration.Url=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Conversations/:ConversationSid/Webhooks/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateServiceNotification

{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications

QUERY PARAMS

ChatServiceSid

BODY formUrlEncoded

AddedToConversation.Enabled

AddedToConversation.Sound

AddedToConversation.Template

LogEnabled

NewMessage.BadgeCountEnabled

NewMessage.Enabled

NewMessage.Sound

NewMessage.Template

NewMessage.WithMedia.Enabled

NewMessage.WithMedia.Template

RemovedFromConversation.Enabled

RemovedFromConversation.Sound

RemovedFromConversation.Template

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "AddedToConversation.Enabled=&AddedToConversation.Sound=&AddedToConversation.Template=&LogEnabled=&NewMessage.BadgeCountEnabled=&NewMessage.Enabled=&NewMessage.Sound=&NewMessage.Template=&NewMessage.WithMedia.Enabled=&NewMessage.WithMedia.Template=&RemovedFromConversation.Enabled=&RemovedFromConversation.Sound=&RemovedFromConversation.Template=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications" {:form-params {:AddedToConversation.Enabled ""
                                                                                                                  :AddedToConversation.Sound ""
                                                                                                                  :AddedToConversation.Template ""
                                                                                                                  :LogEnabled ""
                                                                                                                  :NewMessage.BadgeCountEnabled ""
                                                                                                                  :NewMessage.Enabled ""
                                                                                                                  :NewMessage.Sound ""
                                                                                                                  :NewMessage.Template ""
                                                                                                                  :NewMessage.WithMedia.Enabled ""
                                                                                                                  :NewMessage.WithMedia.Template ""
                                                                                                                  :RemovedFromConversation.Enabled ""
                                                                                                                  :RemovedFromConversation.Sound ""
                                                                                                                  :RemovedFromConversation.Template ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "AddedToConversation.Enabled=&AddedToConversation.Sound=&AddedToConversation.Template=&LogEnabled=&NewMessage.BadgeCountEnabled=&NewMessage.Enabled=&NewMessage.Sound=&NewMessage.Template=&NewMessage.WithMedia.Enabled=&NewMessage.WithMedia.Template=&RemovedFromConversation.Enabled=&RemovedFromConversation.Sound=&RemovedFromConversation.Template="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "AddedToConversation.Enabled", "" },
        { "AddedToConversation.Sound", "" },
        { "AddedToConversation.Template", "" },
        { "LogEnabled", "" },
        { "NewMessage.BadgeCountEnabled", "" },
        { "NewMessage.Enabled", "" },
        { "NewMessage.Sound", "" },
        { "NewMessage.Template", "" },
        { "NewMessage.WithMedia.Enabled", "" },
        { "NewMessage.WithMedia.Template", "" },
        { "RemovedFromConversation.Enabled", "" },
        { "RemovedFromConversation.Sound", "" },
        { "RemovedFromConversation.Template", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "AddedToConversation.Enabled=&AddedToConversation.Sound=&AddedToConversation.Template=&LogEnabled=&NewMessage.BadgeCountEnabled=&NewMessage.Enabled=&NewMessage.Sound=&NewMessage.Template=&NewMessage.WithMedia.Enabled=&NewMessage.WithMedia.Template=&RemovedFromConversation.Enabled=&RemovedFromConversation.Sound=&RemovedFromConversation.Template=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications"

	payload := strings.NewReader("AddedToConversation.Enabled=&AddedToConversation.Sound=&AddedToConversation.Template=&LogEnabled=&NewMessage.BadgeCountEnabled=&NewMessage.Enabled=&NewMessage.Sound=&NewMessage.Template=&NewMessage.WithMedia.Enabled=&NewMessage.WithMedia.Template=&RemovedFromConversation.Enabled=&RemovedFromConversation.Sound=&RemovedFromConversation.Template=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Services/:ChatServiceSid/Configuration/Notifications HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 345

AddedToConversation.Enabled=&AddedToConversation.Sound=&AddedToConversation.Template=&LogEnabled=&NewMessage.BadgeCountEnabled=&NewMessage.Enabled=&NewMessage.Sound=&NewMessage.Template=&NewMessage.WithMedia.Enabled=&NewMessage.WithMedia.Template=&RemovedFromConversation.Enabled=&RemovedFromConversation.Sound=&RemovedFromConversation.Template=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("AddedToConversation.Enabled=&AddedToConversation.Sound=&AddedToConversation.Template=&LogEnabled=&NewMessage.BadgeCountEnabled=&NewMessage.Enabled=&NewMessage.Sound=&NewMessage.Template=&NewMessage.WithMedia.Enabled=&NewMessage.WithMedia.Template=&RemovedFromConversation.Enabled=&RemovedFromConversation.Sound=&RemovedFromConversation.Template=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("AddedToConversation.Enabled=&AddedToConversation.Sound=&AddedToConversation.Template=&LogEnabled=&NewMessage.BadgeCountEnabled=&NewMessage.Enabled=&NewMessage.Sound=&NewMessage.Template=&NewMessage.WithMedia.Enabled=&NewMessage.WithMedia.Template=&RemovedFromConversation.Enabled=&RemovedFromConversation.Sound=&RemovedFromConversation.Template="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "AddedToConversation.Enabled=&AddedToConversation.Sound=&AddedToConversation.Template=&LogEnabled=&NewMessage.BadgeCountEnabled=&NewMessage.Enabled=&NewMessage.Sound=&NewMessage.Template=&NewMessage.WithMedia.Enabled=&NewMessage.WithMedia.Template=&RemovedFromConversation.Enabled=&RemovedFromConversation.Sound=&RemovedFromConversation.Template=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("AddedToConversation.Enabled=&AddedToConversation.Sound=&AddedToConversation.Template=&LogEnabled=&NewMessage.BadgeCountEnabled=&NewMessage.Enabled=&NewMessage.Sound=&NewMessage.Template=&NewMessage.WithMedia.Enabled=&NewMessage.WithMedia.Template=&RemovedFromConversation.Enabled=&RemovedFromConversation.Sound=&RemovedFromConversation.Template=")
  .asString();

const data = 'AddedToConversation.Enabled=&AddedToConversation.Sound=&AddedToConversation.Template=&LogEnabled=&NewMessage.BadgeCountEnabled=&NewMessage.Enabled=&NewMessage.Sound=&NewMessage.Template=&NewMessage.WithMedia.Enabled=&NewMessage.WithMedia.Template=&RemovedFromConversation.Enabled=&RemovedFromConversation.Sound=&RemovedFromConversation.Template=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('AddedToConversation.Enabled', '');
encodedParams.set('AddedToConversation.Sound', '');
encodedParams.set('AddedToConversation.Template', '');
encodedParams.set('LogEnabled', '');
encodedParams.set('NewMessage.BadgeCountEnabled', '');
encodedParams.set('NewMessage.Enabled', '');
encodedParams.set('NewMessage.Sound', '');
encodedParams.set('NewMessage.Template', '');
encodedParams.set('NewMessage.WithMedia.Enabled', '');
encodedParams.set('NewMessage.WithMedia.Template', '');
encodedParams.set('RemovedFromConversation.Enabled', '');
encodedParams.set('RemovedFromConversation.Sound', '');
encodedParams.set('RemovedFromConversation.Template', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    'AddedToConversation.Enabled': '',
    'AddedToConversation.Sound': '',
    'AddedToConversation.Template': '',
    LogEnabled: '',
    'NewMessage.BadgeCountEnabled': '',
    'NewMessage.Enabled': '',
    'NewMessage.Sound': '',
    'NewMessage.Template': '',
    'NewMessage.WithMedia.Enabled': '',
    'NewMessage.WithMedia.Template': '',
    'RemovedFromConversation.Enabled': '',
    'RemovedFromConversation.Sound': '',
    'RemovedFromConversation.Template': ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    'AddedToConversation.Enabled': '',
    'AddedToConversation.Sound': '',
    'AddedToConversation.Template': '',
    LogEnabled: '',
    'NewMessage.BadgeCountEnabled': '',
    'NewMessage.Enabled': '',
    'NewMessage.Sound': '',
    'NewMessage.Template': '',
    'NewMessage.WithMedia.Enabled': '',
    'NewMessage.WithMedia.Template': '',
    'RemovedFromConversation.Enabled': '',
    'RemovedFromConversation.Sound': '',
    'RemovedFromConversation.Template': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "AddedToConversation.Enabled=&AddedToConversation.Sound=&AddedToConversation.Template=&LogEnabled=&NewMessage.BadgeCountEnabled=&NewMessage.Enabled=&NewMessage.Sound=&NewMessage.Template=&NewMessage.WithMedia.Enabled=&NewMessage.WithMedia.Template=&RemovedFromConversation.Enabled=&RemovedFromConversation.Sound=&RemovedFromConversation.Template=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Configuration/Notifications',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({
  'AddedToConversation.Enabled': '',
  'AddedToConversation.Sound': '',
  'AddedToConversation.Template': '',
  LogEnabled: '',
  'NewMessage.BadgeCountEnabled': '',
  'NewMessage.Enabled': '',
  'NewMessage.Sound': '',
  'NewMessage.Template': '',
  'NewMessage.WithMedia.Enabled': '',
  'NewMessage.WithMedia.Template': '',
  'RemovedFromConversation.Enabled': '',
  'RemovedFromConversation.Sound': '',
  'RemovedFromConversation.Template': ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    'AddedToConversation.Enabled': '',
    'AddedToConversation.Sound': '',
    'AddedToConversation.Template': '',
    LogEnabled: '',
    'NewMessage.BadgeCountEnabled': '',
    'NewMessage.Enabled': '',
    'NewMessage.Sound': '',
    'NewMessage.Template': '',
    'NewMessage.WithMedia.Enabled': '',
    'NewMessage.WithMedia.Template': '',
    'RemovedFromConversation.Enabled': '',
    'RemovedFromConversation.Sound': '',
    'RemovedFromConversation.Template': ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  'AddedToConversation.Enabled': '',
  'AddedToConversation.Sound': '',
  'AddedToConversation.Template': '',
  LogEnabled: '',
  'NewMessage.BadgeCountEnabled': '',
  'NewMessage.Enabled': '',
  'NewMessage.Sound': '',
  'NewMessage.Template': '',
  'NewMessage.WithMedia.Enabled': '',
  'NewMessage.WithMedia.Template': '',
  'RemovedFromConversation.Enabled': '',
  'RemovedFromConversation.Sound': '',
  'RemovedFromConversation.Template': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('AddedToConversation.Enabled', '');
encodedParams.set('AddedToConversation.Sound', '');
encodedParams.set('AddedToConversation.Template', '');
encodedParams.set('LogEnabled', '');
encodedParams.set('NewMessage.BadgeCountEnabled', '');
encodedParams.set('NewMessage.Enabled', '');
encodedParams.set('NewMessage.Sound', '');
encodedParams.set('NewMessage.Template', '');
encodedParams.set('NewMessage.WithMedia.Enabled', '');
encodedParams.set('NewMessage.WithMedia.Template', '');
encodedParams.set('RemovedFromConversation.Enabled', '');
encodedParams.set('RemovedFromConversation.Sound', '');
encodedParams.set('RemovedFromConversation.Template', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('AddedToConversation.Enabled', '');
encodedParams.set('AddedToConversation.Sound', '');
encodedParams.set('AddedToConversation.Template', '');
encodedParams.set('LogEnabled', '');
encodedParams.set('NewMessage.BadgeCountEnabled', '');
encodedParams.set('NewMessage.Enabled', '');
encodedParams.set('NewMessage.Sound', '');
encodedParams.set('NewMessage.Template', '');
encodedParams.set('NewMessage.WithMedia.Enabled', '');
encodedParams.set('NewMessage.WithMedia.Template', '');
encodedParams.set('RemovedFromConversation.Enabled', '');
encodedParams.set('RemovedFromConversation.Sound', '');
encodedParams.set('RemovedFromConversation.Template', '');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"AddedToConversation.Enabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AddedToConversation.Sound=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&AddedToConversation.Template=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&LogEnabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&NewMessage.BadgeCountEnabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&NewMessage.Enabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&NewMessage.Sound=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&NewMessage.Template=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&NewMessage.WithMedia.Enabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&NewMessage.WithMedia.Template=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&RemovedFromConversation.Enabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&RemovedFromConversation.Sound=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&RemovedFromConversation.Template=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "AddedToConversation.Enabled=&AddedToConversation.Sound=&AddedToConversation.Template=&LogEnabled=&NewMessage.BadgeCountEnabled=&NewMessage.Enabled=&NewMessage.Sound=&NewMessage.Template=&NewMessage.WithMedia.Enabled=&NewMessage.WithMedia.Template=&RemovedFromConversation.Enabled=&RemovedFromConversation.Sound=&RemovedFromConversation.Template=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "AddedToConversation.Enabled=&AddedToConversation.Sound=&AddedToConversation.Template=&LogEnabled=&NewMessage.BadgeCountEnabled=&NewMessage.Enabled=&NewMessage.Sound=&NewMessage.Template=&NewMessage.WithMedia.Enabled=&NewMessage.WithMedia.Template=&RemovedFromConversation.Enabled=&RemovedFromConversation.Sound=&RemovedFromConversation.Template=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications', [
  'form_params' => [
    'AddedToConversation.Enabled' => '',
    'AddedToConversation.Sound' => '',
    'AddedToConversation.Template' => '',
    'LogEnabled' => '',
    'NewMessage.BadgeCountEnabled' => '',
    'NewMessage.Enabled' => '',
    'NewMessage.Sound' => '',
    'NewMessage.Template' => '',
    'NewMessage.WithMedia.Enabled' => '',
    'NewMessage.WithMedia.Template' => '',
    'RemovedFromConversation.Enabled' => '',
    'RemovedFromConversation.Sound' => '',
    'RemovedFromConversation.Template' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'AddedToConversation.Enabled' => '',
  'AddedToConversation.Sound' => '',
  'AddedToConversation.Template' => '',
  'LogEnabled' => '',
  'NewMessage.BadgeCountEnabled' => '',
  'NewMessage.Enabled' => '',
  'NewMessage.Sound' => '',
  'NewMessage.Template' => '',
  'NewMessage.WithMedia.Enabled' => '',
  'NewMessage.WithMedia.Template' => '',
  'RemovedFromConversation.Enabled' => '',
  'RemovedFromConversation.Sound' => '',
  'RemovedFromConversation.Template' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'AddedToConversation.Enabled' => '',
  'AddedToConversation.Sound' => '',
  'AddedToConversation.Template' => '',
  'LogEnabled' => '',
  'NewMessage.BadgeCountEnabled' => '',
  'NewMessage.Enabled' => '',
  'NewMessage.Sound' => '',
  'NewMessage.Template' => '',
  'NewMessage.WithMedia.Enabled' => '',
  'NewMessage.WithMedia.Template' => '',
  'RemovedFromConversation.Enabled' => '',
  'RemovedFromConversation.Sound' => '',
  'RemovedFromConversation.Template' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AddedToConversation.Enabled=&AddedToConversation.Sound=&AddedToConversation.Template=&LogEnabled=&NewMessage.BadgeCountEnabled=&NewMessage.Enabled=&NewMessage.Sound=&NewMessage.Template=&NewMessage.WithMedia.Enabled=&NewMessage.WithMedia.Template=&RemovedFromConversation.Enabled=&RemovedFromConversation.Sound=&RemovedFromConversation.Template='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'AddedToConversation.Enabled=&AddedToConversation.Sound=&AddedToConversation.Template=&LogEnabled=&NewMessage.BadgeCountEnabled=&NewMessage.Enabled=&NewMessage.Sound=&NewMessage.Template=&NewMessage.WithMedia.Enabled=&NewMessage.WithMedia.Template=&RemovedFromConversation.Enabled=&RemovedFromConversation.Sound=&RemovedFromConversation.Template='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "AddedToConversation.Enabled=&AddedToConversation.Sound=&AddedToConversation.Template=&LogEnabled=&NewMessage.BadgeCountEnabled=&NewMessage.Enabled=&NewMessage.Sound=&NewMessage.Template=&NewMessage.WithMedia.Enabled=&NewMessage.WithMedia.Template=&RemovedFromConversation.Enabled=&RemovedFromConversation.Sound=&RemovedFromConversation.Template="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ChatServiceSid/Configuration/Notifications", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications"

payload = {
    "AddedToConversation.Enabled": "",
    "AddedToConversation.Sound": "",
    "AddedToConversation.Template": "",
    "LogEnabled": "",
    "NewMessage.BadgeCountEnabled": "",
    "NewMessage.Enabled": "",
    "NewMessage.Sound": "",
    "NewMessage.Template": "",
    "NewMessage.WithMedia.Enabled": "",
    "NewMessage.WithMedia.Template": "",
    "RemovedFromConversation.Enabled": "",
    "RemovedFromConversation.Sound": "",
    "RemovedFromConversation.Template": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications"

payload <- "AddedToConversation.Enabled=&AddedToConversation.Sound=&AddedToConversation.Template=&LogEnabled=&NewMessage.BadgeCountEnabled=&NewMessage.Enabled=&NewMessage.Sound=&NewMessage.Template=&NewMessage.WithMedia.Enabled=&NewMessage.WithMedia.Template=&RemovedFromConversation.Enabled=&RemovedFromConversation.Sound=&RemovedFromConversation.Template="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "AddedToConversation.Enabled=&AddedToConversation.Sound=&AddedToConversation.Template=&LogEnabled=&NewMessage.BadgeCountEnabled=&NewMessage.Enabled=&NewMessage.Sound=&NewMessage.Template=&NewMessage.WithMedia.Enabled=&NewMessage.WithMedia.Template=&RemovedFromConversation.Enabled=&RemovedFromConversation.Sound=&RemovedFromConversation.Template="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :AddedToConversation.Enabled => "",
  :AddedToConversation.Sound => "",
  :AddedToConversation.Template => "",
  :LogEnabled => "",
  :NewMessage.BadgeCountEnabled => "",
  :NewMessage.Enabled => "",
  :NewMessage.Sound => "",
  :NewMessage.Template => "",
  :NewMessage.WithMedia.Enabled => "",
  :NewMessage.WithMedia.Template => "",
  :RemovedFromConversation.Enabled => "",
  :RemovedFromConversation.Sound => "",
  :RemovedFromConversation.Template => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ChatServiceSid/Configuration/Notifications') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications";

    let payload = json!({
        "AddedToConversation.Enabled": "",
        "AddedToConversation.Sound": "",
        "AddedToConversation.Template": "",
        "LogEnabled": "",
        "NewMessage.BadgeCountEnabled": "",
        "NewMessage.Enabled": "",
        "NewMessage.Sound": "",
        "NewMessage.Template": "",
        "NewMessage.WithMedia.Enabled": "",
        "NewMessage.WithMedia.Template": "",
        "RemovedFromConversation.Enabled": "",
        "RemovedFromConversation.Sound": "",
        "RemovedFromConversation.Template": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data AddedToConversation.Enabled= \
  --data AddedToConversation.Sound= \
  --data AddedToConversation.Template= \
  --data LogEnabled= \
  --data NewMessage.BadgeCountEnabled= \
  --data NewMessage.Enabled= \
  --data NewMessage.Sound= \
  --data NewMessage.Template= \
  --data NewMessage.WithMedia.Enabled= \
  --data NewMessage.WithMedia.Template= \
  --data RemovedFromConversation.Enabled= \
  --data RemovedFromConversation.Sound= \
  --data RemovedFromConversation.Template=

http --form POST {{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications \
  content-type:application/x-www-form-urlencoded \
  AddedToConversation.Enabled='' \
  AddedToConversation.Sound='' \
  AddedToConversation.Template='' \
  LogEnabled='' \
  NewMessage.BadgeCountEnabled='' \
  NewMessage.Enabled='' \
  NewMessage.Sound='' \
  NewMessage.Template='' \
  NewMessage.WithMedia.Enabled='' \
  NewMessage.WithMedia.Template='' \
  RemovedFromConversation.Enabled='' \
  RemovedFromConversation.Sound='' \
  RemovedFromConversation.Template=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'AddedToConversation.Enabled=&AddedToConversation.Sound=&AddedToConversation.Template=&LogEnabled=&NewMessage.BadgeCountEnabled=&NewMessage.Enabled=&NewMessage.Sound=&NewMessage.Template=&NewMessage.WithMedia.Enabled=&NewMessage.WithMedia.Template=&RemovedFromConversation.Enabled=&RemovedFromConversation.Sound=&RemovedFromConversation.Template=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "AddedToConversation.Enabled=".data(using: String.Encoding.utf8)!)
postData.append("&AddedToConversation.Sound=".data(using: String.Encoding.utf8)!)
postData.append("&AddedToConversation.Template=".data(using: String.Encoding.utf8)!)
postData.append("&LogEnabled=".data(using: String.Encoding.utf8)!)
postData.append("&NewMessage.BadgeCountEnabled=".data(using: String.Encoding.utf8)!)
postData.append("&NewMessage.Enabled=".data(using: String.Encoding.utf8)!)
postData.append("&NewMessage.Sound=".data(using: String.Encoding.utf8)!)
postData.append("&NewMessage.Template=".data(using: String.Encoding.utf8)!)
postData.append("&NewMessage.WithMedia.Enabled=".data(using: String.Encoding.utf8)!)
postData.append("&NewMessage.WithMedia.Template=".data(using: String.Encoding.utf8)!)
postData.append("&RemovedFromConversation.Enabled=".data(using: String.Encoding.utf8)!)
postData.append("&RemovedFromConversation.Sound=".data(using: String.Encoding.utf8)!)
postData.append("&RemovedFromConversation.Template=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Notifications")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateServiceRole

{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid

QUERY PARAMS

ChatServiceSid

Sid

BODY formUrlEncoded

Permission

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Permission=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid" {:form-params {:Permission ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Permission="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Permission", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Permission=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"

	payload := strings.NewReader("Permission=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Services/:ChatServiceSid/Roles/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 11

Permission=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Permission=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Permission="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Permission=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Permission=")
  .asString();

const data = 'Permission=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Permission', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Permission: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Permission: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Permission=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Roles/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({Permission: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Permission: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Permission: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Permission', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Permission', '');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Permission=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Permission=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Permission=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid', [
  'form_params' => [
    'Permission' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Permission' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Permission' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Permission='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Permission='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Permission="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ChatServiceSid/Roles/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"

payload = { "Permission": "" }
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid"

payload <- "Permission="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Permission="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Permission => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ChatServiceSid/Roles/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid";

    let payload = json!({"Permission": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Permission=

http --form POST {{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid \
  content-type:application/x-www-form-urlencoded \
  Permission=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data Permission= \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Permission=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Roles/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateServiceUser

{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid

QUERY PARAMS

ChatServiceSid

Sid

BODY formUrlEncoded

Attributes

FriendlyName

RoleSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Attributes=&FriendlyName=&RoleSid=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid" {:form-params {:Attributes ""
                                                                                                 :FriendlyName ""
                                                                                                 :RoleSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&FriendlyName=&RoleSid="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "FriendlyName", "" },
        { "RoleSid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&FriendlyName=&RoleSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"

	payload := strings.NewReader("Attributes=&FriendlyName=&RoleSid=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Services/:ChatServiceSid/Users/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 34

Attributes=&FriendlyName=&RoleSid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Attributes=&FriendlyName=&RoleSid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&FriendlyName=&RoleSid="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Attributes=&FriendlyName=&RoleSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&FriendlyName=&RoleSid=")
  .asString();

const data = 'Attributes=&FriendlyName=&RoleSid=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Attributes: '', FriendlyName: '', RoleSid: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    FriendlyName: '',
    RoleSid: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Attributes=&FriendlyName=&RoleSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Users/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({Attributes: '', FriendlyName: '', RoleSid: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Attributes: '', FriendlyName: '', RoleSid: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Attributes: '',
  FriendlyName: '',
  RoleSid: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('RoleSid', '');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&RoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&FriendlyName=&RoleSid=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Attributes=&FriendlyName=&RoleSid=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid', [
  'form_params' => [
    'Attributes' => '',
    'FriendlyName' => '',
    'RoleSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Attributes' => '',
  'FriendlyName' => '',
  'RoleSid' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Attributes' => '',
  'FriendlyName' => '',
  'RoleSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&FriendlyName=&RoleSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&FriendlyName=&RoleSid='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Attributes=&FriendlyName=&RoleSid="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ChatServiceSid/Users/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"

payload = {
    "Attributes": "",
    "FriendlyName": "",
    "RoleSid": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid"

payload <- "Attributes=&FriendlyName=&RoleSid="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Attributes=&FriendlyName=&RoleSid="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Attributes => "",
  :FriendlyName => "",
  :RoleSid => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ChatServiceSid/Users/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid";

    let payload = json!({
        "Attributes": "",
        "FriendlyName": "",
        "RoleSid": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data FriendlyName= \
  --data RoleSid=

http --form POST {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  FriendlyName='' \
  RoleSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&FriendlyName=&RoleSid=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&RoleSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateServiceUserConversation

{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid

QUERY PARAMS

ChatServiceSid

UserSid

ConversationSid

BODY formUrlEncoded

LastReadMessageIndex

LastReadTimestamp

NotificationLevel

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid" {:form-params {:LastReadMessageIndex ""
                                                                                                                                    :LastReadTimestamp ""
                                                                                                                                    :NotificationLevel ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "LastReadMessageIndex", "" },
        { "LastReadTimestamp", "" },
        { "NotificationLevel", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"

	payload := strings.NewReader("LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 59

LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=")
  .asString();

const data = 'LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('LastReadMessageIndex', '');
encodedParams.set('LastReadTimestamp', '');
encodedParams.set('NotificationLevel', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({LastReadMessageIndex: '', LastReadTimestamp: '', NotificationLevel: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    LastReadMessageIndex: '',
    LastReadTimestamp: '',
    NotificationLevel: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({LastReadMessageIndex: '', LastReadTimestamp: '', NotificationLevel: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {LastReadMessageIndex: '', LastReadTimestamp: '', NotificationLevel: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  LastReadMessageIndex: '',
  LastReadTimestamp: '',
  NotificationLevel: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('LastReadMessageIndex', '');
encodedParams.set('LastReadTimestamp', '');
encodedParams.set('NotificationLevel', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('LastReadMessageIndex', '');
encodedParams.set('LastReadTimestamp', '');
encodedParams.set('NotificationLevel', '');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"LastReadMessageIndex=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&LastReadTimestamp=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&NotificationLevel=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid', [
  'form_params' => [
    'LastReadMessageIndex' => '',
    'LastReadTimestamp' => '',
    'NotificationLevel' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'LastReadMessageIndex' => '',
  'LastReadTimestamp' => '',
  'NotificationLevel' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'LastReadMessageIndex' => '',
  'LastReadTimestamp' => '',
  'NotificationLevel' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"

payload = {
    "LastReadMessageIndex": "",
    "LastReadTimestamp": "",
    "NotificationLevel": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid"

payload <- "LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :LastReadMessageIndex => "",
  :LastReadTimestamp => "",
  :NotificationLevel => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid";

    let payload = json!({
        "LastReadMessageIndex": "",
        "LastReadTimestamp": "",
        "NotificationLevel": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data LastReadMessageIndex= \
  --data LastReadTimestamp= \
  --data NotificationLevel=

http --form POST {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid \
  content-type:application/x-www-form-urlencoded \
  LastReadMessageIndex='' \
  LastReadTimestamp='' \
  NotificationLevel=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "LastReadMessageIndex=".data(using: String.Encoding.utf8)!)
postData.append("&LastReadTimestamp=".data(using: String.Encoding.utf8)!)
postData.append("&NotificationLevel=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Users/:UserSid/Conversations/:ConversationSid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateServiceWebhookConfiguration

{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks

QUERY PARAMS

ChatServiceSid

BODY formUrlEncoded

Filters

Method

PostWebhookUrl

PreWebhookUrl

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks" {:form-params {:Filters ""
                                                                                                             :Method ""
                                                                                                             :PostWebhookUrl ""
                                                                                                             :PreWebhookUrl ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Filters=&Method=&PostWebhookUrl=&PreWebhookUrl="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Filters", "" },
        { "Method", "" },
        { "PostWebhookUrl", "" },
        { "PreWebhookUrl", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks"

	payload := strings.NewReader("Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Services/:ChatServiceSid/Configuration/Webhooks HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 47

Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Filters=&Method=&PostWebhookUrl=&PreWebhookUrl="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=")
  .asString();

const data = 'Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Filters', '');
encodedParams.set('Method', '');
encodedParams.set('PostWebhookUrl', '');
encodedParams.set('PreWebhookUrl', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Filters: '', Method: '', PostWebhookUrl: '', PreWebhookUrl: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Filters: '',
    Method: '',
    PostWebhookUrl: '',
    PreWebhookUrl: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Services/:ChatServiceSid/Configuration/Webhooks',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({Filters: '', Method: '', PostWebhookUrl: '', PreWebhookUrl: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Filters: '', Method: '', PostWebhookUrl: '', PreWebhookUrl: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Filters: '',
  Method: '',
  PostWebhookUrl: '',
  PreWebhookUrl: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Filters', '');
encodedParams.set('Method', '');
encodedParams.set('PostWebhookUrl', '');
encodedParams.set('PreWebhookUrl', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Filters', '');
encodedParams.set('Method', '');
encodedParams.set('PostWebhookUrl', '');
encodedParams.set('PreWebhookUrl', '');

const url = '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Filters=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&PostWebhookUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&PreWebhookUrl=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks', [
  'form_params' => [
    'Filters' => '',
    'Method' => '',
    'PostWebhookUrl' => '',
    'PreWebhookUrl' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Filters' => '',
  'Method' => '',
  'PostWebhookUrl' => '',
  'PreWebhookUrl' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Filters' => '',
  'Method' => '',
  'PostWebhookUrl' => '',
  'PreWebhookUrl' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Filters=&Method=&PostWebhookUrl=&PreWebhookUrl='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Filters=&Method=&PostWebhookUrl=&PreWebhookUrl='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Filters=&Method=&PostWebhookUrl=&PreWebhookUrl="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Services/:ChatServiceSid/Configuration/Webhooks", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks"

payload = {
    "Filters": "",
    "Method": "",
    "PostWebhookUrl": "",
    "PreWebhookUrl": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks"

payload <- "Filters=&Method=&PostWebhookUrl=&PreWebhookUrl="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Filters=&Method=&PostWebhookUrl=&PreWebhookUrl="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Filters => "",
  :Method => "",
  :PostWebhookUrl => "",
  :PreWebhookUrl => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Services/:ChatServiceSid/Configuration/Webhooks') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks";

    let payload = json!({
        "Filters": "",
        "Method": "",
        "PostWebhookUrl": "",
        "PreWebhookUrl": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Filters= \
  --data Method= \
  --data PostWebhookUrl= \
  --data PreWebhookUrl=

http --form POST {{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks \
  content-type:application/x-www-form-urlencoded \
  Filters='' \
  Method='' \
  PostWebhookUrl='' \
  PreWebhookUrl=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Filters=&Method=&PostWebhookUrl=&PreWebhookUrl=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Filters=".data(using: String.Encoding.utf8)!)
postData.append("&Method=".data(using: String.Encoding.utf8)!)
postData.append("&PostWebhookUrl=".data(using: String.Encoding.utf8)!)
postData.append("&PreWebhookUrl=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ChatServiceSid/Configuration/Webhooks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateUser

{{baseUrl}}/v1/Users/:Sid

QUERY PARAMS

Sid

BODY formUrlEncoded

Attributes

FriendlyName

RoleSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Users/:Sid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "Attributes=&FriendlyName=&RoleSid=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Users/:Sid" {:form-params {:Attributes ""
                                                                        :FriendlyName ""
                                                                        :RoleSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Users/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&FriendlyName=&RoleSid="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Users/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "FriendlyName", "" },
        { "RoleSid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Users/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&FriendlyName=&RoleSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Users/:Sid"

	payload := strings.NewReader("Attributes=&FriendlyName=&RoleSid=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Users/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 34

Attributes=&FriendlyName=&RoleSid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Users/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("Attributes=&FriendlyName=&RoleSid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Users/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&FriendlyName=&RoleSid="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "Attributes=&FriendlyName=&RoleSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Users/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Users/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&FriendlyName=&RoleSid=")
  .asString();

const data = 'Attributes=&FriendlyName=&RoleSid=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Users/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Users/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Users/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Attributes: '', FriendlyName: '', RoleSid: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Users/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    FriendlyName: '',
    RoleSid: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "Attributes=&FriendlyName=&RoleSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Users/:Sid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Users/:Sid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({Attributes: '', FriendlyName: '', RoleSid: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Users/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Attributes: '', FriendlyName: '', RoleSid: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Users/:Sid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  Attributes: '',
  FriendlyName: '',
  RoleSid: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Users/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('Attributes', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('RoleSid', '');

const url = '{{baseUrl}}/v1/Users/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"Attributes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&RoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Users/:Sid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Users/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&FriendlyName=&RoleSid=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Users/:Sid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "Attributes=&FriendlyName=&RoleSid=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Users/:Sid', [
  'form_params' => [
    'Attributes' => '',
    'FriendlyName' => '',
    'RoleSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Users/:Sid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'Attributes' => '',
  'FriendlyName' => '',
  'RoleSid' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'Attributes' => '',
  'FriendlyName' => '',
  'RoleSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Users/:Sid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Users/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&FriendlyName=&RoleSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Users/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&FriendlyName=&RoleSid='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "Attributes=&FriendlyName=&RoleSid="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Users/:Sid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Users/:Sid"

payload = {
    "Attributes": "",
    "FriendlyName": "",
    "RoleSid": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Users/:Sid"

payload <- "Attributes=&FriendlyName=&RoleSid="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Users/:Sid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "Attributes=&FriendlyName=&RoleSid="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :Attributes => "",
  :FriendlyName => "",
  :RoleSid => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Users/:Sid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Users/:Sid";

    let payload = json!({
        "Attributes": "",
        "FriendlyName": "",
        "RoleSid": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Users/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data FriendlyName= \
  --data RoleSid=

http --form POST {{baseUrl}}/v1/Users/:Sid \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  FriendlyName='' \
  RoleSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&FriendlyName=&RoleSid=' \
  --output-document \
  - {{baseUrl}}/v1/Users/:Sid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&RoleSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Users/:Sid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateUserConversation

{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid

QUERY PARAMS

UserSid

ConversationSid

BODY formUrlEncoded

LastReadMessageIndex

LastReadTimestamp

NotificationLevel

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid" {:form-params {:LastReadMessageIndex ""
                                                                                                           :LastReadTimestamp ""
                                                                                                           :NotificationLevel ""}})

require "http/client"

url = "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "LastReadMessageIndex", "" },
        { "LastReadTimestamp", "" },
        { "NotificationLevel", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"

	payload := strings.NewReader("LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/Users/:UserSid/Conversations/:ConversationSid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 59

LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=")
  .asString();

const data = 'LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('LastReadMessageIndex', '');
encodedParams.set('LastReadTimestamp', '');
encodedParams.set('NotificationLevel', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({LastReadMessageIndex: '', LastReadTimestamp: '', NotificationLevel: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    LastReadMessageIndex: '',
    LastReadTimestamp: '',
    NotificationLevel: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/Users/:UserSid/Conversations/:ConversationSid',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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(qs.stringify({LastReadMessageIndex: '', LastReadTimestamp: '', NotificationLevel: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {LastReadMessageIndex: '', LastReadTimestamp: '', NotificationLevel: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  LastReadMessageIndex: '',
  LastReadTimestamp: '',
  NotificationLevel: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('LastReadMessageIndex', '');
encodedParams.set('LastReadTimestamp', '');
encodedParams.set('NotificationLevel', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('LastReadMessageIndex', '');
encodedParams.set('LastReadTimestamp', '');
encodedParams.set('NotificationLevel', '');

const url = '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"LastReadMessageIndex=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&LastReadTimestamp=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&NotificationLevel=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[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];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid', [
  'form_params' => [
    'LastReadMessageIndex' => '',
    'LastReadTimestamp' => '',
    'NotificationLevel' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'LastReadMessageIndex' => '',
  'LastReadTimestamp' => '',
  'NotificationLevel' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'LastReadMessageIndex' => '',
  'LastReadTimestamp' => '',
  'NotificationLevel' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v1/Users/:UserSid/Conversations/:ConversationSid", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"

payload = {
    "LastReadMessageIndex": "",
    "LastReadTimestamp": "",
    "NotificationLevel": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid"

payload <- "LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :LastReadMessageIndex => "",
  :LastReadTimestamp => "",
  :NotificationLevel => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v1/Users/:UserSid/Conversations/:ConversationSid') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid";

    let payload = json!({
        "LastReadMessageIndex": "",
        "LastReadTimestamp": "",
        "NotificationLevel": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data LastReadMessageIndex= \
  --data LastReadTimestamp= \
  --data NotificationLevel=

http --form POST {{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid \
  content-type:application/x-www-form-urlencoded \
  LastReadMessageIndex='' \
  LastReadTimestamp='' \
  NotificationLevel=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'LastReadMessageIndex=&LastReadTimestamp=&NotificationLevel=' \
  --output-document \
  - {{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "LastReadMessageIndex=".data(using: String.Encoding.utf8)!)
postData.append("&LastReadTimestamp=".data(using: String.Encoding.utf8)!)
postData.append("&NotificationLevel=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Users/:UserSid/Conversations/:ConversationSid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()