Twilio - Ip_messaging

POST CreateChannel

{{baseUrl}}/v1/Services/:ServiceSid/Channels

QUERY PARAMS

ServiceSid

BODY formUrlEncoded

Attributes

FriendlyName

Type

UniqueName

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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=&Type=&UniqueName=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Channels" {:form-params {:Attributes ""
                                                                                           :FriendlyName ""
                                                                                           :Type ""
                                                                                           :UniqueName ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&FriendlyName=&Type=&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/:ServiceSid/Channels"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "FriendlyName", "" },
        { "Type", "" },
        { "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/:ServiceSid/Channels");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&FriendlyName=&Type=&UniqueName=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("Attributes=&FriendlyName=&Type=&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/:ServiceSid/Channels HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 43

Attributes=&FriendlyName=&Type=&UniqueName=

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&FriendlyName=&Type=&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=&FriendlyName=&Type=&UniqueName=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

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

const data = 'Attributes=&FriendlyName=&Type=&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/:ServiceSid/Channels');
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('Type', '');
encodedParams.set('UniqueName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels',
  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/:ServiceSid/Channels';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Attributes: '', FriendlyName: '', Type: '', 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/:ServiceSid/Channels',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    FriendlyName: '',
    Type: '',
    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=&FriendlyName=&Type=&UniqueName=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels")
  .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/:ServiceSid/Channels',
  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: '', Type: '', UniqueName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Attributes: '', FriendlyName: '', Type: '', 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/:ServiceSid/Channels');

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

req.form({
  Attributes: '',
  FriendlyName: '',
  Type: '',
  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('FriendlyName', '');
encodedParams.set('Type', '');
encodedParams.set('UniqueName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels',
  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('Type', '');
encodedParams.set('UniqueName', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels';
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:[@"&Type=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&UniqueName=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ServiceSid/Channels"]
                                                       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/:ServiceSid/Channels" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&FriendlyName=&Type=&UniqueName=" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels",
  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=&Type=&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/:ServiceSid/Channels', [
  'form_params' => [
    'Attributes' => '',
    'FriendlyName' => '',
    'Type' => '',
    'UniqueName' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels');
$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' => '',
  'Type' => '',
  'UniqueName' => ''
]);

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

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

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

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels');
$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/:ServiceSid/Channels' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&FriendlyName=&Type=&UniqueName='

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

import http.client

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

payload = "Attributes=&FriendlyName=&Type=&UniqueName="

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

conn.request("POST", "/baseUrl/v1/Services/:ServiceSid/Channels", payload, headers)

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

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

import requests

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

payload = {
    "Attributes": "",
    "FriendlyName": "",
    "Type": "",
    "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/:ServiceSid/Channels"

payload <- "Attributes=&FriendlyName=&Type=&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/:ServiceSid/Channels")

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=&Type=&UniqueName="

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

require 'faraday'

data = {
  :Attributes => "",
  :FriendlyName => "",
  :Type => "",
  :UniqueName => "",
}

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

response = conn.post('/baseUrl/v1/Services/:ServiceSid/Channels') 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/:ServiceSid/Channels";

    let payload = json!({
        "Attributes": "",
        "FriendlyName": "",
        "Type": "",
        "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/:ServiceSid/Channels \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data FriendlyName= \
  --data Type= \
  --data UniqueName=

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Channels \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  FriendlyName='' \
  Type='' \
  UniqueName=''

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

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("&Type=".data(using: String.Encoding.utf8)!)
postData.append("&UniqueName=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels")! 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 CreateInvite

{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites

QUERY PARAMS

ServiceSid

ChannelSid

BODY formUrlEncoded

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/:ServiceSid/Channels/:ChannelSid/Invites");

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, "Identity=&RoleSid=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites" {:form-params {:Identity ""
                                                                                                               :RoleSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "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/:ServiceSid/Channels/:ChannelSid/Invites"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "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/:ServiceSid/Channels/:ChannelSid/Invites");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Identity=&RoleSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites"

	payload := strings.NewReader("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/:ServiceSid/Channels/:ChannelSid/Invites HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 18

Identity=&RoleSid=

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("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, "Identity=&RoleSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Identity=&RoleSid=")
  .asString();

const data = '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/:ServiceSid/Channels/:ChannelSid/Invites');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites',
  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/:ServiceSid/Channels/:ChannelSid/Invites';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({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/:ServiceSid/Channels/:ChannelSid/Invites',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    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, "Identity=&RoleSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites")
  .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/:ServiceSid/Channels/:ChannelSid/Invites',
  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({Identity: '', RoleSid: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {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/:ServiceSid/Channels/:ChannelSid/Invites');

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

req.form({
  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('Identity', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites',
  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('Identity', '');
encodedParams.set('RoleSid', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites';
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:[@"Identity=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&RoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites"]
                                                       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/:ServiceSid/Channels/:ChannelSid/Invites" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Identity=&RoleSid=" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "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/:ServiceSid/Channels/:ChannelSid/Invites', [
  'form_params' => [
    'Identity' => '',
    'RoleSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(new http\QueryString([
  'Identity' => '',
  'RoleSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites');
$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/:ServiceSid/Channels/:ChannelSid/Invites' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Identity=&RoleSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Identity=&RoleSid='

import http.client

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

payload = "Identity=&RoleSid="

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

conn.request("POST", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites"

payload = {
    "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/:ServiceSid/Channels/:ChannelSid/Invites"

payload <- "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/:ServiceSid/Channels/:ChannelSid/Invites")

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 = "Identity=&RoleSid="

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

require 'faraday'

data = {
  :Identity => "",
  :RoleSid => "",
}

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

response = conn.post('/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites') 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/:ServiceSid/Channels/:ChannelSid/Invites";

    let payload = json!({
        "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/:ServiceSid/Channels/:ChannelSid/Invites \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Identity= \
  --data RoleSid=

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites \
  content-type:application/x-www-form-urlencoded \
  Identity='' \
  RoleSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Identity=&RoleSid=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites

import Foundation

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

let postData = NSMutableData(data: "Identity=".data(using: String.Encoding.utf8)!)
postData.append("&RoleSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites")! 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 CreateMember

{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members

QUERY PARAMS

ServiceSid

ChannelSid

BODY formUrlEncoded

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/:ServiceSid/Channels/:ChannelSid/Members");

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, "Identity=&RoleSid=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members" {:form-params {:Identity ""
                                                                                                               :RoleSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "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/:ServiceSid/Channels/:ChannelSid/Members"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "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/:ServiceSid/Channels/:ChannelSid/Members");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Identity=&RoleSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members"

	payload := strings.NewReader("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/:ServiceSid/Channels/:ChannelSid/Members HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 18

Identity=&RoleSid=

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("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, "Identity=&RoleSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Identity=&RoleSid=")
  .asString();

const data = '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/:ServiceSid/Channels/:ChannelSid/Members');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members',
  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/:ServiceSid/Channels/:ChannelSid/Members';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({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/:ServiceSid/Channels/:ChannelSid/Members',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    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, "Identity=&RoleSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members")
  .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/:ServiceSid/Channels/:ChannelSid/Members',
  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({Identity: '', RoleSid: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {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/:ServiceSid/Channels/:ChannelSid/Members');

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

req.form({
  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('Identity', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members',
  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('Identity', '');
encodedParams.set('RoleSid', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members';
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:[@"Identity=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&RoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members"]
                                                       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/:ServiceSid/Channels/:ChannelSid/Members" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Identity=&RoleSid=" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "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/:ServiceSid/Channels/:ChannelSid/Members', [
  'form_params' => [
    'Identity' => '',
    'RoleSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(new http\QueryString([
  'Identity' => '',
  'RoleSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members');
$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/:ServiceSid/Channels/:ChannelSid/Members' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Identity=&RoleSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Identity=&RoleSid='

import http.client

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

payload = "Identity=&RoleSid="

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

conn.request("POST", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Members", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members"

payload = {
    "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/:ServiceSid/Channels/:ChannelSid/Members"

payload <- "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/:ServiceSid/Channels/:ChannelSid/Members")

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 = "Identity=&RoleSid="

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

require 'faraday'

data = {
  :Identity => "",
  :RoleSid => "",
}

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

response = conn.post('/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Members') 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/:ServiceSid/Channels/:ChannelSid/Members";

    let payload = json!({
        "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/:ServiceSid/Channels/:ChannelSid/Members \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Identity= \
  --data RoleSid=

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members \
  content-type:application/x-www-form-urlencoded \
  Identity='' \
  RoleSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Identity=&RoleSid=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members

import Foundation

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

let postData = NSMutableData(data: "Identity=".data(using: String.Encoding.utf8)!)
postData.append("&RoleSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members")! 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 CreateMessage

{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages

QUERY PARAMS

ServiceSid

ChannelSid

BODY formUrlEncoded

Attributes

Body

From

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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=&Body=&From=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages" {:form-params {:Attributes ""
                                                                                                                :Body ""
                                                                                                                :From ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&Body=&From="

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/:ServiceSid/Channels/:ChannelSid/Messages"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "Body", "" },
        { "From", "" },
    }),
};
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/:ServiceSid/Channels/:ChannelSid/Messages");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "Attributes=&Body=&From=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages"

	payload := strings.NewReader("Attributes=&Body=&From=")

	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/:ServiceSid/Channels/:ChannelSid/Messages HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 23

Attributes=&Body=&From=

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&Body=&From="))
    .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=&Body=&From=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&Body=&From=")
  .asString();

const data = 'Attributes=&Body=&From=';

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/:ServiceSid/Channels/:ChannelSid/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('Body', '');
encodedParams.set('From', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Attributes: '', Body: '', From: ''})
};

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/:ServiceSid/Channels/:ChannelSid/Messages',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    Body: '',
    From: ''
  }
};

$.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=&Body=&From=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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: '', Body: '', From: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Attributes: '', Body: '', From: ''}
};

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/:ServiceSid/Channels/:ChannelSid/Messages');

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

req.form({
  Attributes: '',
  Body: '',
  From: ''
});

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('Body', '');
encodedParams.set('From', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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('Body', '');
encodedParams.set('From', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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:[@"&Body=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&From=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "Attributes=&Body=&From=" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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=&Body=&From=",
  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/:ServiceSid/Channels/:ChannelSid/Messages', [
  'form_params' => [
    'Attributes' => '',
    'Body' => '',
    'From' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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' => '',
  'Body' => '',
  'From' => ''
]);

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

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

append(new http\QueryString([
  'Attributes' => '',
  'Body' => '',
  'From' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&Body=&From='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&Body=&From='

import http.client

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

payload = "Attributes=&Body=&From="

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

conn.request("POST", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages"

payload = {
    "Attributes": "",
    "Body": "",
    "From": ""
}
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/:ServiceSid/Channels/:ChannelSid/Messages"

payload <- "Attributes=&Body=&From="

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/:ServiceSid/Channels/:ChannelSid/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=&Body=&From="

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

require 'faraday'

data = {
  :Attributes => "",
  :Body => "",
  :From => "",
}

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

response = conn.post('/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages";

    let payload = json!({
        "Attributes": "",
        "Body": "",
        "From": ""
    });

    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/:ServiceSid/Channels/:ChannelSid/Messages \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data Body= \
  --data From=

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  Body='' \
  From=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&Body=&From=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages

import Foundation

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

let postData = NSMutableData(data: "Attributes=".data(using: String.Encoding.utf8)!)
postData.append("&Body=".data(using: String.Encoding.utf8)!)
postData.append("&From=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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 CreateRole

{{baseUrl}}/v1/Services/:ServiceSid/Roles

QUERY PARAMS

ServiceSid

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/:ServiceSid/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/:ServiceSid/Roles" {:form-params {:FriendlyName ""
                                                                                        :Permission ""
                                                                                        :Type ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Roles', [
  'form_params' => [
    'FriendlyName' => '',
    'Permission' => '',
    'Type' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Roles", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Roles \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data FriendlyName= \
  --data Permission= \
  --data Type=

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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 CreateUser

{{baseUrl}}/v1/Services/:ServiceSid/Users

QUERY PARAMS

ServiceSid

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/:ServiceSid/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/:ServiceSid/Users" {:form-params {:Attributes ""
                                                                                        :FriendlyName ""
                                                                                        :Identity ""
                                                                                        :RoleSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Users', [
  'form_params' => [
    'Attributes' => '',
    'FriendlyName' => '',
    'Identity' => '',
    'RoleSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Users", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Users \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data FriendlyName= \
  --data Identity= \
  --data RoleSid=

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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 DeleteChannel

{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid

QUERY PARAMS

ServiceSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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/:ServiceSid/Channels/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/:Sid")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/:Sid',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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/:ServiceSid/Channels/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Services/:ServiceSid/Channels/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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/:ServiceSid/Channels/:Sid

http DELETE {{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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 DeleteInvite

{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid

QUERY PARAMS

ServiceSid

ChannelSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/:Sid")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/:Sid',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/:Sid

http DELETE {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/: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 DeleteMember

{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid

QUERY PARAMS

ServiceSid

ChannelSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/:Sid")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/:Sid',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/:Sid

http DELETE {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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 DeleteMessage

{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid

QUERY PARAMS

ServiceSid

ChannelSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid

http DELETE {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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 DeleteRole

{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid

QUERY PARAMS

ServiceSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Roles/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Roles/:Sid")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Roles/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Roles/:Sid',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Roles/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Roles/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Services/:ServiceSid/Roles/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Roles/:Sid

http DELETE {{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/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 DeleteUser

{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid

QUERY PARAMS

ServiceSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Users/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Users/:Sid")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Users/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Users/:Sid',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Users/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Users/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1/Services/:ServiceSid/Users/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Users/:Sid

http DELETE {{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/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()

GET FetchChannel

{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid

QUERY PARAMS

ServiceSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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/:ServiceSid/Channels/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/:Sid")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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/:ServiceSid/Channels/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Channels/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/:Sid

http GET {{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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 FetchInvite

{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid

QUERY PARAMS

ServiceSid

ChannelSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/:Sid")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/: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/:ServiceSid/Channels/:ChannelSid/Invites/:Sid

http GET {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites/: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 FetchMember

{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid

QUERY PARAMS

ServiceSid

ChannelSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/:Sid")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/:Sid

http GET {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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 FetchMessage

{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid

QUERY PARAMS

ServiceSid

ChannelSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid

http GET {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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 FetchRole

{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid

QUERY PARAMS

ServiceSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Roles/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Roles/:Sid")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Roles/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Roles/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Roles/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Roles/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Roles/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Roles/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Roles/:Sid

http GET {{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/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 FetchUser

{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid

QUERY PARAMS

ServiceSid

Sid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Users/:Sid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Users/:Sid")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Users/:Sid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Users/:Sid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Users/:Sid" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Users/:Sid');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Users/:Sid")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Users/:Sid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Users/:Sid

http GET {{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/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 ListChannel

{{baseUrl}}/v1/Services/:ServiceSid/Channels

QUERY PARAMS

ServiceSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Channels")

require "http/client"

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

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/:ServiceSid/Channels"),
};
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/:ServiceSid/Channels");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

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

	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/:ServiceSid/Channels HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Channels")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels"))
    .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/:ServiceSid/Channels")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Channels")
  .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/:ServiceSid/Channels');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels';
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/:ServiceSid/Channels',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels")
  .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/:ServiceSid/Channels',
  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/:ServiceSid/Channels'
};

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/:ServiceSid/Channels');

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/:ServiceSid/Channels'
};

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/:ServiceSid/Channels';
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/:ServiceSid/Channels"]
                                                       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/:ServiceSid/Channels" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels",
  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/:ServiceSid/Channels');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Channels")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Channels")

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/:ServiceSid/Channels') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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/:ServiceSid/Channels

http GET {{baseUrl}}/v1/Services/:ServiceSid/Channels

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels")! 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 ListInvite

{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites

QUERY PARAMS

ServiceSid

ChannelSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites"

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/:ServiceSid/Channels/:ChannelSid/Invites"),
};
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/:ServiceSid/Channels/:ChannelSid/Invites");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites"

	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/:ServiceSid/Channels/:ChannelSid/Invites HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites"))
    .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/:ServiceSid/Channels/:ChannelSid/Invites")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites")
  .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/:ServiceSid/Channels/:ChannelSid/Invites');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites';
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/:ServiceSid/Channels/:ChannelSid/Invites',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites")
  .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/:ServiceSid/Channels/:ChannelSid/Invites',
  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/:ServiceSid/Channels/:ChannelSid/Invites'
};

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/:ServiceSid/Channels/:ChannelSid/Invites');

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/:ServiceSid/Channels/:ChannelSid/Invites'
};

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/:ServiceSid/Channels/:ChannelSid/Invites';
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/:ServiceSid/Channels/:ChannelSid/Invites"]
                                                       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/:ServiceSid/Channels/:ChannelSid/Invites" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites",
  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/:ServiceSid/Channels/:ChannelSid/Invites');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites")

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/:ServiceSid/Channels/:ChannelSid/Invites') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites";

    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/:ServiceSid/Channels/:ChannelSid/Invites

http GET {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Invites")! 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 ListMember

{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members

QUERY PARAMS

ServiceSid

ChannelSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members"

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/:ServiceSid/Channels/:ChannelSid/Members"),
};
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/:ServiceSid/Channels/:ChannelSid/Members");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members"

	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/:ServiceSid/Channels/:ChannelSid/Members HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members"))
    .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/:ServiceSid/Channels/:ChannelSid/Members")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members")
  .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/:ServiceSid/Channels/:ChannelSid/Members');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members';
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/:ServiceSid/Channels/:ChannelSid/Members',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members")
  .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/:ServiceSid/Channels/:ChannelSid/Members',
  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/:ServiceSid/Channels/:ChannelSid/Members'
};

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/:ServiceSid/Channels/:ChannelSid/Members');

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/:ServiceSid/Channels/:ChannelSid/Members'
};

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/:ServiceSid/Channels/:ChannelSid/Members';
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/:ServiceSid/Channels/:ChannelSid/Members"]
                                                       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/:ServiceSid/Channels/:ChannelSid/Members" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members",
  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/:ServiceSid/Channels/:ChannelSid/Members');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Members")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members")

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/:ServiceSid/Channels/:ChannelSid/Members') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members";

    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/:ServiceSid/Channels/:ChannelSid/Members

http GET {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members")! 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 ListMessage

{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages

QUERY PARAMS

ServiceSid

ChannelSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages

http GET {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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 ListRole

{{baseUrl}}/v1/Services/:ServiceSid/Roles

QUERY PARAMS

ServiceSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Roles");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Roles")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Roles HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Roles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Roles")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Roles');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Roles'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Roles',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Roles" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Roles');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Roles');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Roles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Roles' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Roles' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Roles")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Roles"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Roles') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Roles

http GET {{baseUrl}}/v1/Services/:ServiceSid/Roles

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Roles

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/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 ListUser

{{baseUrl}}/v1/Services/:ServiceSid/Users

QUERY PARAMS

ServiceSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Users");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Users")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Users HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Users")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Users")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Users');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Users'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Users',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Users" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Users');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Users');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Users');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Users' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Users' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Users")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Users"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Users') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/Users

http GET {{baseUrl}}/v1/Services/:ServiceSid/Users

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Users

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/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 ListUserChannel

{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels

QUERY PARAMS

ServiceSid

UserSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels")

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels"

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/:ServiceSid/Users/:UserSid/Channels"),
};
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/:ServiceSid/Users/:UserSid/Channels");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels"

	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/:ServiceSid/Users/:UserSid/Channels HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels"))
    .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/:ServiceSid/Users/:UserSid/Channels")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels")
  .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/:ServiceSid/Users/:UserSid/Channels');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels'
};

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

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels';
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/:ServiceSid/Users/:UserSid/Channels',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels")
  .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/:ServiceSid/Users/:UserSid/Channels',
  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/:ServiceSid/Users/:UserSid/Channels'
};

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/:ServiceSid/Users/:UserSid/Channels');

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/:ServiceSid/Users/:UserSid/Channels'
};

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/:ServiceSid/Users/:UserSid/Channels';
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/:ServiceSid/Users/:UserSid/Channels"]
                                                       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/:ServiceSid/Users/:UserSid/Channels" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels",
  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/:ServiceSid/Users/:UserSid/Channels');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/Services/:ServiceSid/Users/:UserSid/Channels")

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels")

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/:ServiceSid/Users/:UserSid/Channels') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels";

    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/:ServiceSid/Users/:UserSid/Channels

http GET {{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Users/:UserSid/Channels")! 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 UpdateChannel

{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid

QUERY PARAMS

ServiceSid

Sid

BODY formUrlEncoded

Attributes

FriendlyName

UniqueName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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=&UniqueName=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid" {:form-params {:Attributes ""
                                                                                                :FriendlyName ""
                                                                                                :UniqueName ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&FriendlyName=&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/:ServiceSid/Channels/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "FriendlyName", "" },
        { "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/:ServiceSid/Channels/: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=&UniqueName=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid"

	payload := strings.NewReader("Attributes=&FriendlyName=&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/:ServiceSid/Channels/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 37

Attributes=&FriendlyName=&UniqueName=

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&FriendlyName=&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=&FriendlyName=&UniqueName=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&FriendlyName=&UniqueName=")
  .asString();

const data = 'Attributes=&FriendlyName=&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/:ServiceSid/Channels/: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('UniqueName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Attributes: '', FriendlyName: '', 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/:ServiceSid/Channels/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    FriendlyName: '',
    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=&FriendlyName=&UniqueName=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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: '', UniqueName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Attributes: '', FriendlyName: '', 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/:ServiceSid/Channels/:Sid');

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

req.form({
  Attributes: '',
  FriendlyName: '',
  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('FriendlyName', '');
encodedParams.set('UniqueName', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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('UniqueName', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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:[@"&UniqueName=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/: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=&UniqueName=" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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=&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/:ServiceSid/Channels/:Sid', [
  'form_params' => [
    'Attributes' => '',
    'FriendlyName' => '',
    'UniqueName' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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' => '',
  'UniqueName' => ''
]);

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

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

append(new http\QueryString([
  'Attributes' => '',
  'FriendlyName' => '',
  'UniqueName' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&FriendlyName=&UniqueName='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&FriendlyName=&UniqueName='

import http.client

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

payload = "Attributes=&FriendlyName=&UniqueName="

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

conn.request("POST", "/baseUrl/v1/Services/:ServiceSid/Channels/:Sid", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid"

payload = {
    "Attributes": "",
    "FriendlyName": "",
    "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/:ServiceSid/Channels/:Sid"

payload <- "Attributes=&FriendlyName=&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/:ServiceSid/Channels/: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=&UniqueName="

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

require 'faraday'

data = {
  :Attributes => "",
  :FriendlyName => "",
  :UniqueName => "",
}

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

response = conn.post('/baseUrl/v1/Services/:ServiceSid/Channels/: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/:ServiceSid/Channels/:Sid";

    let payload = json!({
        "Attributes": "",
        "FriendlyName": "",
        "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/:ServiceSid/Channels/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data FriendlyName= \
  --data UniqueName=

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Channels/:Sid \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  FriendlyName='' \
  UniqueName=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&FriendlyName=&UniqueName=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/: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("&UniqueName=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/: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

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

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 ""}})

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="

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", "" },
    }),
};
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=", 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=")

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

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

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=")
  .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="))
    .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=");
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=")
  .asString();

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

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

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: ''
  })
};

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: ''
  }
};

$.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=")
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: ''
}));
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: ''
  }
};

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: ''
});

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

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

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

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=" 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=",
  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' => ''
  ],
  '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' => ''
]);

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

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

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

$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='

$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='

import http.client

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

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

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": ""
}
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="

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="

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

require 'faraday'

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

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": ""
    });

    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=

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

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'ApiKey=&Certificate=&FriendlyName=&PrivateKey=&Sandbox=&Secret=' \
  --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)!)

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 UpdateMember

{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid

QUERY PARAMS

ServiceSid

ChannelSid

Sid

BODY formUrlEncoded

LastConsumedMessageIndex

RoleSid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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, "LastConsumedMessageIndex=&RoleSid=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid" {:form-params {:LastConsumedMessageIndex ""
                                                                                                                    :RoleSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "LastConsumedMessageIndex=&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/:ServiceSid/Channels/:ChannelSid/Members/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "LastConsumedMessageIndex", "" },
        { "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/:ServiceSid/Channels/:ChannelSid/Members/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "LastConsumedMessageIndex=&RoleSid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid"

	payload := strings.NewReader("LastConsumedMessageIndex=&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/:ServiceSid/Channels/:ChannelSid/Members/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 34

LastConsumedMessageIndex=&RoleSid=

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("LastConsumedMessageIndex=&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, "LastConsumedMessageIndex=&RoleSid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("LastConsumedMessageIndex=&RoleSid=")
  .asString();

const data = 'LastConsumedMessageIndex=&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/:ServiceSid/Channels/:ChannelSid/Members/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({LastConsumedMessageIndex: '', 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/:ServiceSid/Channels/:ChannelSid/Members/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    LastConsumedMessageIndex: '',
    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, "LastConsumedMessageIndex=&RoleSid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/: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({LastConsumedMessageIndex: '', RoleSid: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {LastConsumedMessageIndex: '', 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/:ServiceSid/Channels/:ChannelSid/Members/:Sid');

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

req.form({
  LastConsumedMessageIndex: '',
  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('LastConsumedMessageIndex', '');
encodedParams.set('RoleSid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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('LastConsumedMessageIndex', '');
encodedParams.set('RoleSid', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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:[@"LastConsumedMessageIndex=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&RoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "LastConsumedMessageIndex=&RoleSid=" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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 => "LastConsumedMessageIndex=&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/:ServiceSid/Channels/:ChannelSid/Members/:Sid', [
  'form_params' => [
    'LastConsumedMessageIndex' => '',
    'RoleSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(new http\QueryString([
  'LastConsumedMessageIndex' => '',
  'RoleSid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'LastConsumedMessageIndex=&RoleSid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'LastConsumedMessageIndex=&RoleSid='

import http.client

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

payload = "LastConsumedMessageIndex=&RoleSid="

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

conn.request("POST", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid"

payload = {
    "LastConsumedMessageIndex": "",
    "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/:ServiceSid/Channels/:ChannelSid/Members/:Sid"

payload <- "LastConsumedMessageIndex=&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/:ServiceSid/Channels/:ChannelSid/Members/: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 = "LastConsumedMessageIndex=&RoleSid="

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

require 'faraday'

data = {
  :LastConsumedMessageIndex => "",
  :RoleSid => "",
}

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

response = conn.post('/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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/:ServiceSid/Channels/:ChannelSid/Members/:Sid";

    let payload = json!({
        "LastConsumedMessageIndex": "",
        "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/:ServiceSid/Channels/:ChannelSid/Members/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data LastConsumedMessageIndex= \
  --data RoleSid=

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid \
  content-type:application/x-www-form-urlencoded \
  LastConsumedMessageIndex='' \
  RoleSid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'LastConsumedMessageIndex=&RoleSid=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/:Sid

import Foundation

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

let postData = NSMutableData(data: "LastConsumedMessageIndex=".data(using: String.Encoding.utf8)!)
postData.append("&RoleSid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Members/: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 UpdateMessage

{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid

QUERY PARAMS

ServiceSid

ChannelSid

Sid

BODY formUrlEncoded

Attributes

Body

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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=&Body=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid" {:form-params {:Attributes ""
                                                                                                                     :Body ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "Attributes=&Body="

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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "Attributes", "" },
        { "Body", "" },
    }),
};
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/:ServiceSid/Channels/:ChannelSid/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=&Body=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid"

	payload := strings.NewReader("Attributes=&Body=")

	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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 17

Attributes=&Body=

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("Attributes=&Body="))
    .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=&Body=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("Attributes=&Body=")
  .asString();

const data = 'Attributes=&Body=';

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/:ServiceSid/Channels/:ChannelSid/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('Body', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({Attributes: '', Body: ''})
};

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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    Attributes: '',
    Body: ''
  }
};

$.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=&Body=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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: '', Body: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {Attributes: '', Body: ''}
};

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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid');

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

req.form({
  Attributes: '',
  Body: ''
});

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('Body', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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('Body', '');

const url = '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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:[@"&Body=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/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=&Body=" in

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

 "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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=&Body=",
  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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid', [
  'form_params' => [
    'Attributes' => '',
    'Body' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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' => '',
  'Body' => ''
]);

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

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

append(new http\QueryString([
  'Attributes' => '',
  'Body' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&Body='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'Attributes=&Body='

import http.client

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

payload = "Attributes=&Body="

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

conn.request("POST", "/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid"

payload = {
    "Attributes": "",
    "Body": ""
}
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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid"

payload <- "Attributes=&Body="

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/:ServiceSid/Channels/:ChannelSid/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=&Body="

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

require 'faraday'

data = {
  :Attributes => "",
  :Body => "",
}

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

response = conn.post('/baseUrl/v1/Services/:ServiceSid/Channels/:ChannelSid/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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid";

    let payload = json!({
        "Attributes": "",
        "Body": ""
    });

    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/:ServiceSid/Channels/:ChannelSid/Messages/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data Body=

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/Messages/:Sid \
  content-type:application/x-www-form-urlencoded \
  Attributes='' \
  Body=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'Attributes=&Body=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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("&Body=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/:ServiceSid/Channels/:ChannelSid/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 UpdateRole

{{baseUrl}}/v1/Services/:ServiceSid/Roles/:Sid

QUERY PARAMS

ServiceSid

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/:ServiceSid/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/:ServiceSid/Roles/:Sid" {:form-params {:Permission ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Roles/:Sid', [
  'form_params' => [
    'Permission' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Roles/:Sid", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Roles/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Permission=

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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 UpdateService

{{baseUrl}}/v1/Services/:Sid

QUERY PARAMS

Sid

BODY formUrlEncoded

ConsumptionReportInterval

DefaultChannelCreatorRoleSid

DefaultChannelRoleSid

DefaultServiceRoleSid

FriendlyName

Limits.ChannelMembers

Limits.UserChannels

Notifications.AddedToChannel.Enabled

Notifications.AddedToChannel.Template

Notifications.InvitedToChannel.Enabled

Notifications.InvitedToChannel.Template

Notifications.NewMessage.Enabled

Notifications.NewMessage.Template

Notifications.RemovedFromChannel.Enabled

Notifications.RemovedFromChannel.Template

PostWebhookUrl

PreWebhookUrl

ReachabilityEnabled

ReadStatusEnabled

TypingIndicatorTimeout

WebhookFilters

WebhookMethod

Webhooks.OnChannelAdd.Method

Webhooks.OnChannelAdd.Url

Webhooks.OnChannelAdded.Method

Webhooks.OnChannelAdded.Url

Webhooks.OnChannelDestroy.Method

Webhooks.OnChannelDestroy.Url

Webhooks.OnChannelDestroyed.Method

Webhooks.OnChannelDestroyed.Url

Webhooks.OnChannelUpdate.Method

Webhooks.OnChannelUpdate.Url

Webhooks.OnChannelUpdated.Method

Webhooks.OnChannelUpdated.Url

Webhooks.OnMemberAdd.Method

Webhooks.OnMemberAdd.Url

Webhooks.OnMemberAdded.Method

Webhooks.OnMemberAdded.Url

Webhooks.OnMemberRemove.Method

Webhooks.OnMemberRemove.Url

Webhooks.OnMemberRemoved.Method

Webhooks.OnMemberRemoved.Url

Webhooks.OnMessageRemove.Method

Webhooks.OnMessageRemove.Url

Webhooks.OnMessageRemoved.Method

Webhooks.OnMessageRemoved.Url

Webhooks.OnMessageSend.Method

Webhooks.OnMessageSend.Url

Webhooks.OnMessageSent.Method

Webhooks.OnMessageSent.Url

Webhooks.OnMessageUpdate.Method

Webhooks.OnMessageUpdate.Url

Webhooks.OnMessageUpdated.Method

Webhooks.OnMessageUpdated.Url

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/Services/: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, "ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/Services/:Sid" {:form-params {:ConsumptionReportInterval ""
                                                                           :DefaultChannelCreatorRoleSid ""
                                                                           :DefaultChannelRoleSid ""
                                                                           :DefaultServiceRoleSid ""
                                                                           :FriendlyName ""
                                                                           :Limits.ChannelMembers ""
                                                                           :Limits.UserChannels ""
                                                                           :Notifications.AddedToChannel.Enabled ""
                                                                           :Notifications.AddedToChannel.Template ""
                                                                           :Notifications.InvitedToChannel.Enabled ""
                                                                           :Notifications.InvitedToChannel.Template ""
                                                                           :Notifications.NewMessage.Enabled ""
                                                                           :Notifications.NewMessage.Template ""
                                                                           :Notifications.RemovedFromChannel.Enabled ""
                                                                           :Notifications.RemovedFromChannel.Template ""
                                                                           :PostWebhookUrl ""
                                                                           :PreWebhookUrl ""
                                                                           :ReachabilityEnabled ""
                                                                           :ReadStatusEnabled ""
                                                                           :TypingIndicatorTimeout ""
                                                                           :WebhookFilters ""
                                                                           :WebhookMethod ""
                                                                           :Webhooks.OnChannelAdd.Method ""
                                                                           :Webhooks.OnChannelAdd.Url ""
                                                                           :Webhooks.OnChannelAdded.Method ""
                                                                           :Webhooks.OnChannelAdded.Url ""
                                                                           :Webhooks.OnChannelDestroy.Method ""
                                                                           :Webhooks.OnChannelDestroy.Url ""
                                                                           :Webhooks.OnChannelDestroyed.Method ""
                                                                           :Webhooks.OnChannelDestroyed.Url ""
                                                                           :Webhooks.OnChannelUpdate.Method ""
                                                                           :Webhooks.OnChannelUpdate.Url ""
                                                                           :Webhooks.OnChannelUpdated.Method ""
                                                                           :Webhooks.OnChannelUpdated.Url ""
                                                                           :Webhooks.OnMemberAdd.Method ""
                                                                           :Webhooks.OnMemberAdd.Url ""
                                                                           :Webhooks.OnMemberAdded.Method ""
                                                                           :Webhooks.OnMemberAdded.Url ""
                                                                           :Webhooks.OnMemberRemove.Method ""
                                                                           :Webhooks.OnMemberRemove.Url ""
                                                                           :Webhooks.OnMemberRemoved.Method ""
                                                                           :Webhooks.OnMemberRemoved.Url ""
                                                                           :Webhooks.OnMessageRemove.Method ""
                                                                           :Webhooks.OnMessageRemove.Url ""
                                                                           :Webhooks.OnMessageRemoved.Method ""
                                                                           :Webhooks.OnMessageRemoved.Url ""
                                                                           :Webhooks.OnMessageSend.Method ""
                                                                           :Webhooks.OnMessageSend.Url ""
                                                                           :Webhooks.OnMessageSent.Method ""
                                                                           :Webhooks.OnMessageSent.Url ""
                                                                           :Webhooks.OnMessageUpdate.Method ""
                                                                           :Webhooks.OnMessageUpdate.Url ""
                                                                           :Webhooks.OnMessageUpdated.Method ""
                                                                           :Webhooks.OnMessageUpdated.Url ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:Sid"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.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/:Sid"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "ConsumptionReportInterval", "" },
        { "DefaultChannelCreatorRoleSid", "" },
        { "DefaultChannelRoleSid", "" },
        { "DefaultServiceRoleSid", "" },
        { "FriendlyName", "" },
        { "Limits.ChannelMembers", "" },
        { "Limits.UserChannels", "" },
        { "Notifications.AddedToChannel.Enabled", "" },
        { "Notifications.AddedToChannel.Template", "" },
        { "Notifications.InvitedToChannel.Enabled", "" },
        { "Notifications.InvitedToChannel.Template", "" },
        { "Notifications.NewMessage.Enabled", "" },
        { "Notifications.NewMessage.Template", "" },
        { "Notifications.RemovedFromChannel.Enabled", "" },
        { "Notifications.RemovedFromChannel.Template", "" },
        { "PostWebhookUrl", "" },
        { "PreWebhookUrl", "" },
        { "ReachabilityEnabled", "" },
        { "ReadStatusEnabled", "" },
        { "TypingIndicatorTimeout", "" },
        { "WebhookFilters", "" },
        { "WebhookMethod", "" },
        { "Webhooks.OnChannelAdd.Method", "" },
        { "Webhooks.OnChannelAdd.Url", "" },
        { "Webhooks.OnChannelAdded.Method", "" },
        { "Webhooks.OnChannelAdded.Url", "" },
        { "Webhooks.OnChannelDestroy.Method", "" },
        { "Webhooks.OnChannelDestroy.Url", "" },
        { "Webhooks.OnChannelDestroyed.Method", "" },
        { "Webhooks.OnChannelDestroyed.Url", "" },
        { "Webhooks.OnChannelUpdate.Method", "" },
        { "Webhooks.OnChannelUpdate.Url", "" },
        { "Webhooks.OnChannelUpdated.Method", "" },
        { "Webhooks.OnChannelUpdated.Url", "" },
        { "Webhooks.OnMemberAdd.Method", "" },
        { "Webhooks.OnMemberAdd.Url", "" },
        { "Webhooks.OnMemberAdded.Method", "" },
        { "Webhooks.OnMemberAdded.Url", "" },
        { "Webhooks.OnMemberRemove.Method", "" },
        { "Webhooks.OnMemberRemove.Url", "" },
        { "Webhooks.OnMemberRemoved.Method", "" },
        { "Webhooks.OnMemberRemoved.Url", "" },
        { "Webhooks.OnMessageRemove.Method", "" },
        { "Webhooks.OnMessageRemove.Url", "" },
        { "Webhooks.OnMessageRemoved.Method", "" },
        { "Webhooks.OnMessageRemoved.Url", "" },
        { "Webhooks.OnMessageSend.Method", "" },
        { "Webhooks.OnMessageSend.Url", "" },
        { "Webhooks.OnMessageSent.Method", "" },
        { "Webhooks.OnMessageSent.Url", "" },
        { "Webhooks.OnMessageUpdate.Method", "" },
        { "Webhooks.OnMessageUpdate.Url", "" },
        { "Webhooks.OnMessageUpdated.Method", "" },
        { "Webhooks.OnMessageUpdated.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/:Sid");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.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/:Sid HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 1590

ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/Services/:Sid")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/Services/:Sid"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.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, "ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/Services/: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/:Sid")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=")
  .asString();

const data = 'ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.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/:Sid');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('ConsumptionReportInterval', '');
encodedParams.set('DefaultChannelCreatorRoleSid', '');
encodedParams.set('DefaultChannelRoleSid', '');
encodedParams.set('DefaultServiceRoleSid', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Limits.ChannelMembers', '');
encodedParams.set('Limits.UserChannels', '');
encodedParams.set('Notifications.AddedToChannel.Enabled', '');
encodedParams.set('Notifications.AddedToChannel.Template', '');
encodedParams.set('Notifications.InvitedToChannel.Enabled', '');
encodedParams.set('Notifications.InvitedToChannel.Template', '');
encodedParams.set('Notifications.NewMessage.Enabled', '');
encodedParams.set('Notifications.NewMessage.Template', '');
encodedParams.set('Notifications.RemovedFromChannel.Enabled', '');
encodedParams.set('Notifications.RemovedFromChannel.Template', '');
encodedParams.set('PostWebhookUrl', '');
encodedParams.set('PreWebhookUrl', '');
encodedParams.set('ReachabilityEnabled', '');
encodedParams.set('ReadStatusEnabled', '');
encodedParams.set('TypingIndicatorTimeout', '');
encodedParams.set('WebhookFilters', '');
encodedParams.set('WebhookMethod', '');
encodedParams.set('Webhooks.OnChannelAdd.Method', '');
encodedParams.set('Webhooks.OnChannelAdd.Url', '');
encodedParams.set('Webhooks.OnChannelAdded.Method', '');
encodedParams.set('Webhooks.OnChannelAdded.Url', '');
encodedParams.set('Webhooks.OnChannelDestroy.Method', '');
encodedParams.set('Webhooks.OnChannelDestroy.Url', '');
encodedParams.set('Webhooks.OnChannelDestroyed.Method', '');
encodedParams.set('Webhooks.OnChannelDestroyed.Url', '');
encodedParams.set('Webhooks.OnChannelUpdate.Method', '');
encodedParams.set('Webhooks.OnChannelUpdate.Url', '');
encodedParams.set('Webhooks.OnChannelUpdated.Method', '');
encodedParams.set('Webhooks.OnChannelUpdated.Url', '');
encodedParams.set('Webhooks.OnMemberAdd.Method', '');
encodedParams.set('Webhooks.OnMemberAdd.Url', '');
encodedParams.set('Webhooks.OnMemberAdded.Method', '');
encodedParams.set('Webhooks.OnMemberAdded.Url', '');
encodedParams.set('Webhooks.OnMemberRemove.Method', '');
encodedParams.set('Webhooks.OnMemberRemove.Url', '');
encodedParams.set('Webhooks.OnMemberRemoved.Method', '');
encodedParams.set('Webhooks.OnMemberRemoved.Url', '');
encodedParams.set('Webhooks.OnMessageRemove.Method', '');
encodedParams.set('Webhooks.OnMessageRemove.Url', '');
encodedParams.set('Webhooks.OnMessageRemoved.Method', '');
encodedParams.set('Webhooks.OnMessageRemoved.Url', '');
encodedParams.set('Webhooks.OnMessageSend.Method', '');
encodedParams.set('Webhooks.OnMessageSend.Url', '');
encodedParams.set('Webhooks.OnMessageSent.Method', '');
encodedParams.set('Webhooks.OnMessageSent.Url', '');
encodedParams.set('Webhooks.OnMessageUpdate.Method', '');
encodedParams.set('Webhooks.OnMessageUpdate.Url', '');
encodedParams.set('Webhooks.OnMessageUpdated.Method', '');
encodedParams.set('Webhooks.OnMessageUpdated.Url', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/: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/:Sid';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    ConsumptionReportInterval: '',
    DefaultChannelCreatorRoleSid: '',
    DefaultChannelRoleSid: '',
    DefaultServiceRoleSid: '',
    FriendlyName: '',
    'Limits.ChannelMembers': '',
    'Limits.UserChannels': '',
    'Notifications.AddedToChannel.Enabled': '',
    'Notifications.AddedToChannel.Template': '',
    'Notifications.InvitedToChannel.Enabled': '',
    'Notifications.InvitedToChannel.Template': '',
    'Notifications.NewMessage.Enabled': '',
    'Notifications.NewMessage.Template': '',
    'Notifications.RemovedFromChannel.Enabled': '',
    'Notifications.RemovedFromChannel.Template': '',
    PostWebhookUrl: '',
    PreWebhookUrl: '',
    ReachabilityEnabled: '',
    ReadStatusEnabled: '',
    TypingIndicatorTimeout: '',
    WebhookFilters: '',
    WebhookMethod: '',
    'Webhooks.OnChannelAdd.Method': '',
    'Webhooks.OnChannelAdd.Url': '',
    'Webhooks.OnChannelAdded.Method': '',
    'Webhooks.OnChannelAdded.Url': '',
    'Webhooks.OnChannelDestroy.Method': '',
    'Webhooks.OnChannelDestroy.Url': '',
    'Webhooks.OnChannelDestroyed.Method': '',
    'Webhooks.OnChannelDestroyed.Url': '',
    'Webhooks.OnChannelUpdate.Method': '',
    'Webhooks.OnChannelUpdate.Url': '',
    'Webhooks.OnChannelUpdated.Method': '',
    'Webhooks.OnChannelUpdated.Url': '',
    'Webhooks.OnMemberAdd.Method': '',
    'Webhooks.OnMemberAdd.Url': '',
    'Webhooks.OnMemberAdded.Method': '',
    'Webhooks.OnMemberAdded.Url': '',
    'Webhooks.OnMemberRemove.Method': '',
    'Webhooks.OnMemberRemove.Url': '',
    'Webhooks.OnMemberRemoved.Method': '',
    'Webhooks.OnMemberRemoved.Url': '',
    'Webhooks.OnMessageRemove.Method': '',
    'Webhooks.OnMessageRemove.Url': '',
    'Webhooks.OnMessageRemoved.Method': '',
    'Webhooks.OnMessageRemoved.Url': '',
    'Webhooks.OnMessageSend.Method': '',
    'Webhooks.OnMessageSend.Url': '',
    'Webhooks.OnMessageSent.Method': '',
    'Webhooks.OnMessageSent.Url': '',
    'Webhooks.OnMessageUpdate.Method': '',
    'Webhooks.OnMessageUpdate.Url': '',
    'Webhooks.OnMessageUpdated.Method': '',
    'Webhooks.OnMessageUpdated.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/:Sid',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    ConsumptionReportInterval: '',
    DefaultChannelCreatorRoleSid: '',
    DefaultChannelRoleSid: '',
    DefaultServiceRoleSid: '',
    FriendlyName: '',
    'Limits.ChannelMembers': '',
    'Limits.UserChannels': '',
    'Notifications.AddedToChannel.Enabled': '',
    'Notifications.AddedToChannel.Template': '',
    'Notifications.InvitedToChannel.Enabled': '',
    'Notifications.InvitedToChannel.Template': '',
    'Notifications.NewMessage.Enabled': '',
    'Notifications.NewMessage.Template': '',
    'Notifications.RemovedFromChannel.Enabled': '',
    'Notifications.RemovedFromChannel.Template': '',
    PostWebhookUrl: '',
    PreWebhookUrl: '',
    ReachabilityEnabled: '',
    ReadStatusEnabled: '',
    TypingIndicatorTimeout: '',
    WebhookFilters: '',
    WebhookMethod: '',
    'Webhooks.OnChannelAdd.Method': '',
    'Webhooks.OnChannelAdd.Url': '',
    'Webhooks.OnChannelAdded.Method': '',
    'Webhooks.OnChannelAdded.Url': '',
    'Webhooks.OnChannelDestroy.Method': '',
    'Webhooks.OnChannelDestroy.Url': '',
    'Webhooks.OnChannelDestroyed.Method': '',
    'Webhooks.OnChannelDestroyed.Url': '',
    'Webhooks.OnChannelUpdate.Method': '',
    'Webhooks.OnChannelUpdate.Url': '',
    'Webhooks.OnChannelUpdated.Method': '',
    'Webhooks.OnChannelUpdated.Url': '',
    'Webhooks.OnMemberAdd.Method': '',
    'Webhooks.OnMemberAdd.Url': '',
    'Webhooks.OnMemberAdded.Method': '',
    'Webhooks.OnMemberAdded.Url': '',
    'Webhooks.OnMemberRemove.Method': '',
    'Webhooks.OnMemberRemove.Url': '',
    'Webhooks.OnMemberRemoved.Method': '',
    'Webhooks.OnMemberRemoved.Url': '',
    'Webhooks.OnMessageRemove.Method': '',
    'Webhooks.OnMessageRemove.Url': '',
    'Webhooks.OnMessageRemoved.Method': '',
    'Webhooks.OnMessageRemoved.Url': '',
    'Webhooks.OnMessageSend.Method': '',
    'Webhooks.OnMessageSend.Url': '',
    'Webhooks.OnMessageSent.Method': '',
    'Webhooks.OnMessageSent.Url': '',
    'Webhooks.OnMessageUpdate.Method': '',
    'Webhooks.OnMessageUpdate.Url': '',
    'Webhooks.OnMessageUpdated.Method': '',
    'Webhooks.OnMessageUpdated.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, "ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/Services/: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/: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({
  ConsumptionReportInterval: '',
  DefaultChannelCreatorRoleSid: '',
  DefaultChannelRoleSid: '',
  DefaultServiceRoleSid: '',
  FriendlyName: '',
  'Limits.ChannelMembers': '',
  'Limits.UserChannels': '',
  'Notifications.AddedToChannel.Enabled': '',
  'Notifications.AddedToChannel.Template': '',
  'Notifications.InvitedToChannel.Enabled': '',
  'Notifications.InvitedToChannel.Template': '',
  'Notifications.NewMessage.Enabled': '',
  'Notifications.NewMessage.Template': '',
  'Notifications.RemovedFromChannel.Enabled': '',
  'Notifications.RemovedFromChannel.Template': '',
  PostWebhookUrl: '',
  PreWebhookUrl: '',
  ReachabilityEnabled: '',
  ReadStatusEnabled: '',
  TypingIndicatorTimeout: '',
  WebhookFilters: '',
  WebhookMethod: '',
  'Webhooks.OnChannelAdd.Method': '',
  'Webhooks.OnChannelAdd.Url': '',
  'Webhooks.OnChannelAdded.Method': '',
  'Webhooks.OnChannelAdded.Url': '',
  'Webhooks.OnChannelDestroy.Method': '',
  'Webhooks.OnChannelDestroy.Url': '',
  'Webhooks.OnChannelDestroyed.Method': '',
  'Webhooks.OnChannelDestroyed.Url': '',
  'Webhooks.OnChannelUpdate.Method': '',
  'Webhooks.OnChannelUpdate.Url': '',
  'Webhooks.OnChannelUpdated.Method': '',
  'Webhooks.OnChannelUpdated.Url': '',
  'Webhooks.OnMemberAdd.Method': '',
  'Webhooks.OnMemberAdd.Url': '',
  'Webhooks.OnMemberAdded.Method': '',
  'Webhooks.OnMemberAdded.Url': '',
  'Webhooks.OnMemberRemove.Method': '',
  'Webhooks.OnMemberRemove.Url': '',
  'Webhooks.OnMemberRemoved.Method': '',
  'Webhooks.OnMemberRemoved.Url': '',
  'Webhooks.OnMessageRemove.Method': '',
  'Webhooks.OnMessageRemove.Url': '',
  'Webhooks.OnMessageRemoved.Method': '',
  'Webhooks.OnMessageRemoved.Url': '',
  'Webhooks.OnMessageSend.Method': '',
  'Webhooks.OnMessageSend.Url': '',
  'Webhooks.OnMessageSent.Method': '',
  'Webhooks.OnMessageSent.Url': '',
  'Webhooks.OnMessageUpdate.Method': '',
  'Webhooks.OnMessageUpdate.Url': '',
  'Webhooks.OnMessageUpdated.Method': '',
  'Webhooks.OnMessageUpdated.Url': ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/:Sid',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    ConsumptionReportInterval: '',
    DefaultChannelCreatorRoleSid: '',
    DefaultChannelRoleSid: '',
    DefaultServiceRoleSid: '',
    FriendlyName: '',
    'Limits.ChannelMembers': '',
    'Limits.UserChannels': '',
    'Notifications.AddedToChannel.Enabled': '',
    'Notifications.AddedToChannel.Template': '',
    'Notifications.InvitedToChannel.Enabled': '',
    'Notifications.InvitedToChannel.Template': '',
    'Notifications.NewMessage.Enabled': '',
    'Notifications.NewMessage.Template': '',
    'Notifications.RemovedFromChannel.Enabled': '',
    'Notifications.RemovedFromChannel.Template': '',
    PostWebhookUrl: '',
    PreWebhookUrl: '',
    ReachabilityEnabled: '',
    ReadStatusEnabled: '',
    TypingIndicatorTimeout: '',
    WebhookFilters: '',
    WebhookMethod: '',
    'Webhooks.OnChannelAdd.Method': '',
    'Webhooks.OnChannelAdd.Url': '',
    'Webhooks.OnChannelAdded.Method': '',
    'Webhooks.OnChannelAdded.Url': '',
    'Webhooks.OnChannelDestroy.Method': '',
    'Webhooks.OnChannelDestroy.Url': '',
    'Webhooks.OnChannelDestroyed.Method': '',
    'Webhooks.OnChannelDestroyed.Url': '',
    'Webhooks.OnChannelUpdate.Method': '',
    'Webhooks.OnChannelUpdate.Url': '',
    'Webhooks.OnChannelUpdated.Method': '',
    'Webhooks.OnChannelUpdated.Url': '',
    'Webhooks.OnMemberAdd.Method': '',
    'Webhooks.OnMemberAdd.Url': '',
    'Webhooks.OnMemberAdded.Method': '',
    'Webhooks.OnMemberAdded.Url': '',
    'Webhooks.OnMemberRemove.Method': '',
    'Webhooks.OnMemberRemove.Url': '',
    'Webhooks.OnMemberRemoved.Method': '',
    'Webhooks.OnMemberRemoved.Url': '',
    'Webhooks.OnMessageRemove.Method': '',
    'Webhooks.OnMessageRemove.Url': '',
    'Webhooks.OnMessageRemoved.Method': '',
    'Webhooks.OnMessageRemoved.Url': '',
    'Webhooks.OnMessageSend.Method': '',
    'Webhooks.OnMessageSend.Url': '',
    'Webhooks.OnMessageSent.Method': '',
    'Webhooks.OnMessageSent.Url': '',
    'Webhooks.OnMessageUpdate.Method': '',
    'Webhooks.OnMessageUpdate.Url': '',
    'Webhooks.OnMessageUpdated.Method': '',
    'Webhooks.OnMessageUpdated.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/:Sid');

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

req.form({
  ConsumptionReportInterval: '',
  DefaultChannelCreatorRoleSid: '',
  DefaultChannelRoleSid: '',
  DefaultServiceRoleSid: '',
  FriendlyName: '',
  'Limits.ChannelMembers': '',
  'Limits.UserChannels': '',
  'Notifications.AddedToChannel.Enabled': '',
  'Notifications.AddedToChannel.Template': '',
  'Notifications.InvitedToChannel.Enabled': '',
  'Notifications.InvitedToChannel.Template': '',
  'Notifications.NewMessage.Enabled': '',
  'Notifications.NewMessage.Template': '',
  'Notifications.RemovedFromChannel.Enabled': '',
  'Notifications.RemovedFromChannel.Template': '',
  PostWebhookUrl: '',
  PreWebhookUrl: '',
  ReachabilityEnabled: '',
  ReadStatusEnabled: '',
  TypingIndicatorTimeout: '',
  WebhookFilters: '',
  WebhookMethod: '',
  'Webhooks.OnChannelAdd.Method': '',
  'Webhooks.OnChannelAdd.Url': '',
  'Webhooks.OnChannelAdded.Method': '',
  'Webhooks.OnChannelAdded.Url': '',
  'Webhooks.OnChannelDestroy.Method': '',
  'Webhooks.OnChannelDestroy.Url': '',
  'Webhooks.OnChannelDestroyed.Method': '',
  'Webhooks.OnChannelDestroyed.Url': '',
  'Webhooks.OnChannelUpdate.Method': '',
  'Webhooks.OnChannelUpdate.Url': '',
  'Webhooks.OnChannelUpdated.Method': '',
  'Webhooks.OnChannelUpdated.Url': '',
  'Webhooks.OnMemberAdd.Method': '',
  'Webhooks.OnMemberAdd.Url': '',
  'Webhooks.OnMemberAdded.Method': '',
  'Webhooks.OnMemberAdded.Url': '',
  'Webhooks.OnMemberRemove.Method': '',
  'Webhooks.OnMemberRemove.Url': '',
  'Webhooks.OnMemberRemoved.Method': '',
  'Webhooks.OnMemberRemoved.Url': '',
  'Webhooks.OnMessageRemove.Method': '',
  'Webhooks.OnMessageRemove.Url': '',
  'Webhooks.OnMessageRemoved.Method': '',
  'Webhooks.OnMessageRemoved.Url': '',
  'Webhooks.OnMessageSend.Method': '',
  'Webhooks.OnMessageSend.Url': '',
  'Webhooks.OnMessageSent.Method': '',
  'Webhooks.OnMessageSent.Url': '',
  'Webhooks.OnMessageUpdate.Method': '',
  'Webhooks.OnMessageUpdate.Url': '',
  'Webhooks.OnMessageUpdated.Method': '',
  'Webhooks.OnMessageUpdated.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('ConsumptionReportInterval', '');
encodedParams.set('DefaultChannelCreatorRoleSid', '');
encodedParams.set('DefaultChannelRoleSid', '');
encodedParams.set('DefaultServiceRoleSid', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Limits.ChannelMembers', '');
encodedParams.set('Limits.UserChannels', '');
encodedParams.set('Notifications.AddedToChannel.Enabled', '');
encodedParams.set('Notifications.AddedToChannel.Template', '');
encodedParams.set('Notifications.InvitedToChannel.Enabled', '');
encodedParams.set('Notifications.InvitedToChannel.Template', '');
encodedParams.set('Notifications.NewMessage.Enabled', '');
encodedParams.set('Notifications.NewMessage.Template', '');
encodedParams.set('Notifications.RemovedFromChannel.Enabled', '');
encodedParams.set('Notifications.RemovedFromChannel.Template', '');
encodedParams.set('PostWebhookUrl', '');
encodedParams.set('PreWebhookUrl', '');
encodedParams.set('ReachabilityEnabled', '');
encodedParams.set('ReadStatusEnabled', '');
encodedParams.set('TypingIndicatorTimeout', '');
encodedParams.set('WebhookFilters', '');
encodedParams.set('WebhookMethod', '');
encodedParams.set('Webhooks.OnChannelAdd.Method', '');
encodedParams.set('Webhooks.OnChannelAdd.Url', '');
encodedParams.set('Webhooks.OnChannelAdded.Method', '');
encodedParams.set('Webhooks.OnChannelAdded.Url', '');
encodedParams.set('Webhooks.OnChannelDestroy.Method', '');
encodedParams.set('Webhooks.OnChannelDestroy.Url', '');
encodedParams.set('Webhooks.OnChannelDestroyed.Method', '');
encodedParams.set('Webhooks.OnChannelDestroyed.Url', '');
encodedParams.set('Webhooks.OnChannelUpdate.Method', '');
encodedParams.set('Webhooks.OnChannelUpdate.Url', '');
encodedParams.set('Webhooks.OnChannelUpdated.Method', '');
encodedParams.set('Webhooks.OnChannelUpdated.Url', '');
encodedParams.set('Webhooks.OnMemberAdd.Method', '');
encodedParams.set('Webhooks.OnMemberAdd.Url', '');
encodedParams.set('Webhooks.OnMemberAdded.Method', '');
encodedParams.set('Webhooks.OnMemberAdded.Url', '');
encodedParams.set('Webhooks.OnMemberRemove.Method', '');
encodedParams.set('Webhooks.OnMemberRemove.Url', '');
encodedParams.set('Webhooks.OnMemberRemoved.Method', '');
encodedParams.set('Webhooks.OnMemberRemoved.Url', '');
encodedParams.set('Webhooks.OnMessageRemove.Method', '');
encodedParams.set('Webhooks.OnMessageRemove.Url', '');
encodedParams.set('Webhooks.OnMessageRemoved.Method', '');
encodedParams.set('Webhooks.OnMessageRemoved.Url', '');
encodedParams.set('Webhooks.OnMessageSend.Method', '');
encodedParams.set('Webhooks.OnMessageSend.Url', '');
encodedParams.set('Webhooks.OnMessageSent.Method', '');
encodedParams.set('Webhooks.OnMessageSent.Url', '');
encodedParams.set('Webhooks.OnMessageUpdate.Method', '');
encodedParams.set('Webhooks.OnMessageUpdate.Url', '');
encodedParams.set('Webhooks.OnMessageUpdated.Method', '');
encodedParams.set('Webhooks.OnMessageUpdated.Url', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/Services/: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('ConsumptionReportInterval', '');
encodedParams.set('DefaultChannelCreatorRoleSid', '');
encodedParams.set('DefaultChannelRoleSid', '');
encodedParams.set('DefaultServiceRoleSid', '');
encodedParams.set('FriendlyName', '');
encodedParams.set('Limits.ChannelMembers', '');
encodedParams.set('Limits.UserChannels', '');
encodedParams.set('Notifications.AddedToChannel.Enabled', '');
encodedParams.set('Notifications.AddedToChannel.Template', '');
encodedParams.set('Notifications.InvitedToChannel.Enabled', '');
encodedParams.set('Notifications.InvitedToChannel.Template', '');
encodedParams.set('Notifications.NewMessage.Enabled', '');
encodedParams.set('Notifications.NewMessage.Template', '');
encodedParams.set('Notifications.RemovedFromChannel.Enabled', '');
encodedParams.set('Notifications.RemovedFromChannel.Template', '');
encodedParams.set('PostWebhookUrl', '');
encodedParams.set('PreWebhookUrl', '');
encodedParams.set('ReachabilityEnabled', '');
encodedParams.set('ReadStatusEnabled', '');
encodedParams.set('TypingIndicatorTimeout', '');
encodedParams.set('WebhookFilters', '');
encodedParams.set('WebhookMethod', '');
encodedParams.set('Webhooks.OnChannelAdd.Method', '');
encodedParams.set('Webhooks.OnChannelAdd.Url', '');
encodedParams.set('Webhooks.OnChannelAdded.Method', '');
encodedParams.set('Webhooks.OnChannelAdded.Url', '');
encodedParams.set('Webhooks.OnChannelDestroy.Method', '');
encodedParams.set('Webhooks.OnChannelDestroy.Url', '');
encodedParams.set('Webhooks.OnChannelDestroyed.Method', '');
encodedParams.set('Webhooks.OnChannelDestroyed.Url', '');
encodedParams.set('Webhooks.OnChannelUpdate.Method', '');
encodedParams.set('Webhooks.OnChannelUpdate.Url', '');
encodedParams.set('Webhooks.OnChannelUpdated.Method', '');
encodedParams.set('Webhooks.OnChannelUpdated.Url', '');
encodedParams.set('Webhooks.OnMemberAdd.Method', '');
encodedParams.set('Webhooks.OnMemberAdd.Url', '');
encodedParams.set('Webhooks.OnMemberAdded.Method', '');
encodedParams.set('Webhooks.OnMemberAdded.Url', '');
encodedParams.set('Webhooks.OnMemberRemove.Method', '');
encodedParams.set('Webhooks.OnMemberRemove.Url', '');
encodedParams.set('Webhooks.OnMemberRemoved.Method', '');
encodedParams.set('Webhooks.OnMemberRemoved.Url', '');
encodedParams.set('Webhooks.OnMessageRemove.Method', '');
encodedParams.set('Webhooks.OnMessageRemove.Url', '');
encodedParams.set('Webhooks.OnMessageRemoved.Method', '');
encodedParams.set('Webhooks.OnMessageRemoved.Url', '');
encodedParams.set('Webhooks.OnMessageSend.Method', '');
encodedParams.set('Webhooks.OnMessageSend.Url', '');
encodedParams.set('Webhooks.OnMessageSent.Method', '');
encodedParams.set('Webhooks.OnMessageSent.Url', '');
encodedParams.set('Webhooks.OnMessageUpdate.Method', '');
encodedParams.set('Webhooks.OnMessageUpdate.Url', '');
encodedParams.set('Webhooks.OnMessageUpdated.Method', '');
encodedParams.set('Webhooks.OnMessageUpdated.Url', '');

const url = '{{baseUrl}}/v1/Services/: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:[@"ConsumptionReportInterval=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DefaultChannelCreatorRoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DefaultChannelRoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&DefaultServiceRoleSid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&FriendlyName=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Limits.ChannelMembers=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Limits.UserChannels=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Notifications.AddedToChannel.Enabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Notifications.AddedToChannel.Template=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Notifications.InvitedToChannel.Enabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Notifications.InvitedToChannel.Template=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Notifications.NewMessage.Enabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Notifications.NewMessage.Template=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Notifications.RemovedFromChannel.Enabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Notifications.RemovedFromChannel.Template=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&PostWebhookUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&PreWebhookUrl=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ReachabilityEnabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ReadStatusEnabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&TypingIndicatorTimeout=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&WebhookFilters=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&WebhookMethod=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelAdd.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelAdd.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelAdded.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelAdded.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelDestroy.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelDestroy.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelDestroyed.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelDestroyed.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelUpdate.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelUpdate.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelUpdated.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnChannelUpdated.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMemberAdd.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMemberAdd.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMemberAdded.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMemberAdded.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMemberRemove.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMemberRemove.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMemberRemoved.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMemberRemoved.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageRemove.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageRemove.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageRemoved.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageRemoved.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageSend.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageSend.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageSent.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageSent.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageUpdate.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageUpdate.Url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageUpdated.Method=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&Webhooks.OnMessageUpdated.Url=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/Services/: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/:Sid" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=" in

Client.call ~headers ~body `POST 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 => "POST",
  CURLOPT_POSTFIELDS => "ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.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/:Sid', [
  'form_params' => [
    'ConsumptionReportInterval' => '',
    'DefaultChannelCreatorRoleSid' => '',
    'DefaultChannelRoleSid' => '',
    'DefaultServiceRoleSid' => '',
    'FriendlyName' => '',
    'Limits.ChannelMembers' => '',
    'Limits.UserChannels' => '',
    'Notifications.AddedToChannel.Enabled' => '',
    'Notifications.AddedToChannel.Template' => '',
    'Notifications.InvitedToChannel.Enabled' => '',
    'Notifications.InvitedToChannel.Template' => '',
    'Notifications.NewMessage.Enabled' => '',
    'Notifications.NewMessage.Template' => '',
    'Notifications.RemovedFromChannel.Enabled' => '',
    'Notifications.RemovedFromChannel.Template' => '',
    'PostWebhookUrl' => '',
    'PreWebhookUrl' => '',
    'ReachabilityEnabled' => '',
    'ReadStatusEnabled' => '',
    'TypingIndicatorTimeout' => '',
    'WebhookFilters' => '',
    'WebhookMethod' => '',
    'Webhooks.OnChannelAdd.Method' => '',
    'Webhooks.OnChannelAdd.Url' => '',
    'Webhooks.OnChannelAdded.Method' => '',
    'Webhooks.OnChannelAdded.Url' => '',
    'Webhooks.OnChannelDestroy.Method' => '',
    'Webhooks.OnChannelDestroy.Url' => '',
    'Webhooks.OnChannelDestroyed.Method' => '',
    'Webhooks.OnChannelDestroyed.Url' => '',
    'Webhooks.OnChannelUpdate.Method' => '',
    'Webhooks.OnChannelUpdate.Url' => '',
    'Webhooks.OnChannelUpdated.Method' => '',
    'Webhooks.OnChannelUpdated.Url' => '',
    'Webhooks.OnMemberAdd.Method' => '',
    'Webhooks.OnMemberAdd.Url' => '',
    'Webhooks.OnMemberAdded.Method' => '',
    'Webhooks.OnMemberAdded.Url' => '',
    'Webhooks.OnMemberRemove.Method' => '',
    'Webhooks.OnMemberRemove.Url' => '',
    'Webhooks.OnMemberRemoved.Method' => '',
    'Webhooks.OnMemberRemoved.Url' => '',
    'Webhooks.OnMessageRemove.Method' => '',
    'Webhooks.OnMessageRemove.Url' => '',
    'Webhooks.OnMessageRemoved.Method' => '',
    'Webhooks.OnMessageRemoved.Url' => '',
    'Webhooks.OnMessageSend.Method' => '',
    'Webhooks.OnMessageSend.Url' => '',
    'Webhooks.OnMessageSent.Method' => '',
    'Webhooks.OnMessageSent.Url' => '',
    'Webhooks.OnMessageUpdate.Method' => '',
    'Webhooks.OnMessageUpdate.Url' => '',
    'Webhooks.OnMessageUpdated.Method' => '',
    'Webhooks.OnMessageUpdated.Url' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'ConsumptionReportInterval' => '',
  'DefaultChannelCreatorRoleSid' => '',
  'DefaultChannelRoleSid' => '',
  'DefaultServiceRoleSid' => '',
  'FriendlyName' => '',
  'Limits.ChannelMembers' => '',
  'Limits.UserChannels' => '',
  'Notifications.AddedToChannel.Enabled' => '',
  'Notifications.AddedToChannel.Template' => '',
  'Notifications.InvitedToChannel.Enabled' => '',
  'Notifications.InvitedToChannel.Template' => '',
  'Notifications.NewMessage.Enabled' => '',
  'Notifications.NewMessage.Template' => '',
  'Notifications.RemovedFromChannel.Enabled' => '',
  'Notifications.RemovedFromChannel.Template' => '',
  'PostWebhookUrl' => '',
  'PreWebhookUrl' => '',
  'ReachabilityEnabled' => '',
  'ReadStatusEnabled' => '',
  'TypingIndicatorTimeout' => '',
  'WebhookFilters' => '',
  'WebhookMethod' => '',
  'Webhooks.OnChannelAdd.Method' => '',
  'Webhooks.OnChannelAdd.Url' => '',
  'Webhooks.OnChannelAdded.Method' => '',
  'Webhooks.OnChannelAdded.Url' => '',
  'Webhooks.OnChannelDestroy.Method' => '',
  'Webhooks.OnChannelDestroy.Url' => '',
  'Webhooks.OnChannelDestroyed.Method' => '',
  'Webhooks.OnChannelDestroyed.Url' => '',
  'Webhooks.OnChannelUpdate.Method' => '',
  'Webhooks.OnChannelUpdate.Url' => '',
  'Webhooks.OnChannelUpdated.Method' => '',
  'Webhooks.OnChannelUpdated.Url' => '',
  'Webhooks.OnMemberAdd.Method' => '',
  'Webhooks.OnMemberAdd.Url' => '',
  'Webhooks.OnMemberAdded.Method' => '',
  'Webhooks.OnMemberAdded.Url' => '',
  'Webhooks.OnMemberRemove.Method' => '',
  'Webhooks.OnMemberRemove.Url' => '',
  'Webhooks.OnMemberRemoved.Method' => '',
  'Webhooks.OnMemberRemoved.Url' => '',
  'Webhooks.OnMessageRemove.Method' => '',
  'Webhooks.OnMessageRemove.Url' => '',
  'Webhooks.OnMessageRemoved.Method' => '',
  'Webhooks.OnMessageRemoved.Url' => '',
  'Webhooks.OnMessageSend.Method' => '',
  'Webhooks.OnMessageSend.Url' => '',
  'Webhooks.OnMessageSent.Method' => '',
  'Webhooks.OnMessageSent.Url' => '',
  'Webhooks.OnMessageUpdate.Method' => '',
  'Webhooks.OnMessageUpdate.Url' => '',
  'Webhooks.OnMessageUpdated.Method' => '',
  'Webhooks.OnMessageUpdated.Url' => ''
]);

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

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

append(new http\QueryString([
  'ConsumptionReportInterval' => '',
  'DefaultChannelCreatorRoleSid' => '',
  'DefaultChannelRoleSid' => '',
  'DefaultServiceRoleSid' => '',
  'FriendlyName' => '',
  'Limits.ChannelMembers' => '',
  'Limits.UserChannels' => '',
  'Notifications.AddedToChannel.Enabled' => '',
  'Notifications.AddedToChannel.Template' => '',
  'Notifications.InvitedToChannel.Enabled' => '',
  'Notifications.InvitedToChannel.Template' => '',
  'Notifications.NewMessage.Enabled' => '',
  'Notifications.NewMessage.Template' => '',
  'Notifications.RemovedFromChannel.Enabled' => '',
  'Notifications.RemovedFromChannel.Template' => '',
  'PostWebhookUrl' => '',
  'PreWebhookUrl' => '',
  'ReachabilityEnabled' => '',
  'ReadStatusEnabled' => '',
  'TypingIndicatorTimeout' => '',
  'WebhookFilters' => '',
  'WebhookMethod' => '',
  'Webhooks.OnChannelAdd.Method' => '',
  'Webhooks.OnChannelAdd.Url' => '',
  'Webhooks.OnChannelAdded.Method' => '',
  'Webhooks.OnChannelAdded.Url' => '',
  'Webhooks.OnChannelDestroy.Method' => '',
  'Webhooks.OnChannelDestroy.Url' => '',
  'Webhooks.OnChannelDestroyed.Method' => '',
  'Webhooks.OnChannelDestroyed.Url' => '',
  'Webhooks.OnChannelUpdate.Method' => '',
  'Webhooks.OnChannelUpdate.Url' => '',
  'Webhooks.OnChannelUpdated.Method' => '',
  'Webhooks.OnChannelUpdated.Url' => '',
  'Webhooks.OnMemberAdd.Method' => '',
  'Webhooks.OnMemberAdd.Url' => '',
  'Webhooks.OnMemberAdded.Method' => '',
  'Webhooks.OnMemberAdded.Url' => '',
  'Webhooks.OnMemberRemove.Method' => '',
  'Webhooks.OnMemberRemove.Url' => '',
  'Webhooks.OnMemberRemoved.Method' => '',
  'Webhooks.OnMemberRemoved.Url' => '',
  'Webhooks.OnMessageRemove.Method' => '',
  'Webhooks.OnMessageRemove.Url' => '',
  'Webhooks.OnMessageRemoved.Method' => '',
  'Webhooks.OnMessageRemoved.Url' => '',
  'Webhooks.OnMessageSend.Method' => '',
  'Webhooks.OnMessageSend.Url' => '',
  'Webhooks.OnMessageSent.Method' => '',
  'Webhooks.OnMessageSent.Url' => '',
  'Webhooks.OnMessageUpdate.Method' => '',
  'Webhooks.OnMessageUpdate.Url' => '',
  'Webhooks.OnMessageUpdated.Method' => '',
  'Webhooks.OnMessageUpdated.Url' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v1/Services/: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/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/Services/:Sid' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url='

import http.client

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

payload = "ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url="

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

conn.request("POST", "/baseUrl/v1/Services/:Sid", payload, headers)

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

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

import requests

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

payload = {
    "ConsumptionReportInterval": "",
    "DefaultChannelCreatorRoleSid": "",
    "DefaultChannelRoleSid": "",
    "DefaultServiceRoleSid": "",
    "FriendlyName": "",
    "Limits.ChannelMembers": "",
    "Limits.UserChannels": "",
    "Notifications.AddedToChannel.Enabled": "",
    "Notifications.AddedToChannel.Template": "",
    "Notifications.InvitedToChannel.Enabled": "",
    "Notifications.InvitedToChannel.Template": "",
    "Notifications.NewMessage.Enabled": "",
    "Notifications.NewMessage.Template": "",
    "Notifications.RemovedFromChannel.Enabled": "",
    "Notifications.RemovedFromChannel.Template": "",
    "PostWebhookUrl": "",
    "PreWebhookUrl": "",
    "ReachabilityEnabled": "",
    "ReadStatusEnabled": "",
    "TypingIndicatorTimeout": "",
    "WebhookFilters": "",
    "WebhookMethod": "",
    "Webhooks.OnChannelAdd.Method": "",
    "Webhooks.OnChannelAdd.Url": "",
    "Webhooks.OnChannelAdded.Method": "",
    "Webhooks.OnChannelAdded.Url": "",
    "Webhooks.OnChannelDestroy.Method": "",
    "Webhooks.OnChannelDestroy.Url": "",
    "Webhooks.OnChannelDestroyed.Method": "",
    "Webhooks.OnChannelDestroyed.Url": "",
    "Webhooks.OnChannelUpdate.Method": "",
    "Webhooks.OnChannelUpdate.Url": "",
    "Webhooks.OnChannelUpdated.Method": "",
    "Webhooks.OnChannelUpdated.Url": "",
    "Webhooks.OnMemberAdd.Method": "",
    "Webhooks.OnMemberAdd.Url": "",
    "Webhooks.OnMemberAdded.Method": "",
    "Webhooks.OnMemberAdded.Url": "",
    "Webhooks.OnMemberRemove.Method": "",
    "Webhooks.OnMemberRemove.Url": "",
    "Webhooks.OnMemberRemoved.Method": "",
    "Webhooks.OnMemberRemoved.Url": "",
    "Webhooks.OnMessageRemove.Method": "",
    "Webhooks.OnMessageRemove.Url": "",
    "Webhooks.OnMessageRemoved.Method": "",
    "Webhooks.OnMessageRemoved.Url": "",
    "Webhooks.OnMessageSend.Method": "",
    "Webhooks.OnMessageSend.Url": "",
    "Webhooks.OnMessageSent.Method": "",
    "Webhooks.OnMessageSent.Url": "",
    "Webhooks.OnMessageUpdate.Method": "",
    "Webhooks.OnMessageUpdate.Url": "",
    "Webhooks.OnMessageUpdated.Method": "",
    "Webhooks.OnMessageUpdated.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/:Sid"

payload <- "ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.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/: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 = "ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url="

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

require 'faraday'

data = {
  :ConsumptionReportInterval => "",
  :DefaultChannelCreatorRoleSid => "",
  :DefaultChannelRoleSid => "",
  :DefaultServiceRoleSid => "",
  :FriendlyName => "",
  :Limits.ChannelMembers => "",
  :Limits.UserChannels => "",
  :Notifications.AddedToChannel.Enabled => "",
  :Notifications.AddedToChannel.Template => "",
  :Notifications.InvitedToChannel.Enabled => "",
  :Notifications.InvitedToChannel.Template => "",
  :Notifications.NewMessage.Enabled => "",
  :Notifications.NewMessage.Template => "",
  :Notifications.RemovedFromChannel.Enabled => "",
  :Notifications.RemovedFromChannel.Template => "",
  :PostWebhookUrl => "",
  :PreWebhookUrl => "",
  :ReachabilityEnabled => "",
  :ReadStatusEnabled => "",
  :TypingIndicatorTimeout => "",
  :WebhookFilters => "",
  :WebhookMethod => "",
  :Webhooks.OnChannelAdd.Method => "",
  :Webhooks.OnChannelAdd.Url => "",
  :Webhooks.OnChannelAdded.Method => "",
  :Webhooks.OnChannelAdded.Url => "",
  :Webhooks.OnChannelDestroy.Method => "",
  :Webhooks.OnChannelDestroy.Url => "",
  :Webhooks.OnChannelDestroyed.Method => "",
  :Webhooks.OnChannelDestroyed.Url => "",
  :Webhooks.OnChannelUpdate.Method => "",
  :Webhooks.OnChannelUpdate.Url => "",
  :Webhooks.OnChannelUpdated.Method => "",
  :Webhooks.OnChannelUpdated.Url => "",
  :Webhooks.OnMemberAdd.Method => "",
  :Webhooks.OnMemberAdd.Url => "",
  :Webhooks.OnMemberAdded.Method => "",
  :Webhooks.OnMemberAdded.Url => "",
  :Webhooks.OnMemberRemove.Method => "",
  :Webhooks.OnMemberRemove.Url => "",
  :Webhooks.OnMemberRemoved.Method => "",
  :Webhooks.OnMemberRemoved.Url => "",
  :Webhooks.OnMessageRemove.Method => "",
  :Webhooks.OnMessageRemove.Url => "",
  :Webhooks.OnMessageRemoved.Method => "",
  :Webhooks.OnMessageRemoved.Url => "",
  :Webhooks.OnMessageSend.Method => "",
  :Webhooks.OnMessageSend.Url => "",
  :Webhooks.OnMessageSent.Method => "",
  :Webhooks.OnMessageSent.Url => "",
  :Webhooks.OnMessageUpdate.Method => "",
  :Webhooks.OnMessageUpdate.Url => "",
  :Webhooks.OnMessageUpdated.Method => "",
  :Webhooks.OnMessageUpdated.Url => "",
}

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

response = conn.post('/baseUrl/v1/Services/: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/:Sid";

    let payload = json!({
        "ConsumptionReportInterval": "",
        "DefaultChannelCreatorRoleSid": "",
        "DefaultChannelRoleSid": "",
        "DefaultServiceRoleSid": "",
        "FriendlyName": "",
        "Limits.ChannelMembers": "",
        "Limits.UserChannels": "",
        "Notifications.AddedToChannel.Enabled": "",
        "Notifications.AddedToChannel.Template": "",
        "Notifications.InvitedToChannel.Enabled": "",
        "Notifications.InvitedToChannel.Template": "",
        "Notifications.NewMessage.Enabled": "",
        "Notifications.NewMessage.Template": "",
        "Notifications.RemovedFromChannel.Enabled": "",
        "Notifications.RemovedFromChannel.Template": "",
        "PostWebhookUrl": "",
        "PreWebhookUrl": "",
        "ReachabilityEnabled": "",
        "ReadStatusEnabled": "",
        "TypingIndicatorTimeout": "",
        "WebhookFilters": "",
        "WebhookMethod": "",
        "Webhooks.OnChannelAdd.Method": "",
        "Webhooks.OnChannelAdd.Url": "",
        "Webhooks.OnChannelAdded.Method": "",
        "Webhooks.OnChannelAdded.Url": "",
        "Webhooks.OnChannelDestroy.Method": "",
        "Webhooks.OnChannelDestroy.Url": "",
        "Webhooks.OnChannelDestroyed.Method": "",
        "Webhooks.OnChannelDestroyed.Url": "",
        "Webhooks.OnChannelUpdate.Method": "",
        "Webhooks.OnChannelUpdate.Url": "",
        "Webhooks.OnChannelUpdated.Method": "",
        "Webhooks.OnChannelUpdated.Url": "",
        "Webhooks.OnMemberAdd.Method": "",
        "Webhooks.OnMemberAdd.Url": "",
        "Webhooks.OnMemberAdded.Method": "",
        "Webhooks.OnMemberAdded.Url": "",
        "Webhooks.OnMemberRemove.Method": "",
        "Webhooks.OnMemberRemove.Url": "",
        "Webhooks.OnMemberRemoved.Method": "",
        "Webhooks.OnMemberRemoved.Url": "",
        "Webhooks.OnMessageRemove.Method": "",
        "Webhooks.OnMessageRemove.Url": "",
        "Webhooks.OnMessageRemoved.Method": "",
        "Webhooks.OnMessageRemoved.Url": "",
        "Webhooks.OnMessageSend.Method": "",
        "Webhooks.OnMessageSend.Url": "",
        "Webhooks.OnMessageSent.Method": "",
        "Webhooks.OnMessageSent.Url": "",
        "Webhooks.OnMessageUpdate.Method": "",
        "Webhooks.OnMessageUpdate.Url": "",
        "Webhooks.OnMessageUpdated.Method": "",
        "Webhooks.OnMessageUpdated.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/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data ConsumptionReportInterval= \
  --data DefaultChannelCreatorRoleSid= \
  --data DefaultChannelRoleSid= \
  --data DefaultServiceRoleSid= \
  --data FriendlyName= \
  --data Limits.ChannelMembers= \
  --data Limits.UserChannels= \
  --data Notifications.AddedToChannel.Enabled= \
  --data Notifications.AddedToChannel.Template= \
  --data Notifications.InvitedToChannel.Enabled= \
  --data Notifications.InvitedToChannel.Template= \
  --data Notifications.NewMessage.Enabled= \
  --data Notifications.NewMessage.Template= \
  --data Notifications.RemovedFromChannel.Enabled= \
  --data Notifications.RemovedFromChannel.Template= \
  --data PostWebhookUrl= \
  --data PreWebhookUrl= \
  --data ReachabilityEnabled= \
  --data ReadStatusEnabled= \
  --data TypingIndicatorTimeout= \
  --data WebhookFilters= \
  --data WebhookMethod= \
  --data Webhooks.OnChannelAdd.Method= \
  --data Webhooks.OnChannelAdd.Url= \
  --data Webhooks.OnChannelAdded.Method= \
  --data Webhooks.OnChannelAdded.Url= \
  --data Webhooks.OnChannelDestroy.Method= \
  --data Webhooks.OnChannelDestroy.Url= \
  --data Webhooks.OnChannelDestroyed.Method= \
  --data Webhooks.OnChannelDestroyed.Url= \
  --data Webhooks.OnChannelUpdate.Method= \
  --data Webhooks.OnChannelUpdate.Url= \
  --data Webhooks.OnChannelUpdated.Method= \
  --data Webhooks.OnChannelUpdated.Url= \
  --data Webhooks.OnMemberAdd.Method= \
  --data Webhooks.OnMemberAdd.Url= \
  --data Webhooks.OnMemberAdded.Method= \
  --data Webhooks.OnMemberAdded.Url= \
  --data Webhooks.OnMemberRemove.Method= \
  --data Webhooks.OnMemberRemove.Url= \
  --data Webhooks.OnMemberRemoved.Method= \
  --data Webhooks.OnMemberRemoved.Url= \
  --data Webhooks.OnMessageRemove.Method= \
  --data Webhooks.OnMessageRemove.Url= \
  --data Webhooks.OnMessageRemoved.Method= \
  --data Webhooks.OnMessageRemoved.Url= \
  --data Webhooks.OnMessageSend.Method= \
  --data Webhooks.OnMessageSend.Url= \
  --data Webhooks.OnMessageSent.Method= \
  --data Webhooks.OnMessageSent.Url= \
  --data Webhooks.OnMessageUpdate.Method= \
  --data Webhooks.OnMessageUpdate.Url= \
  --data Webhooks.OnMessageUpdated.Method= \
  --data Webhooks.OnMessageUpdated.Url=

http --form POST {{baseUrl}}/v1/Services/:Sid \
  content-type:application/x-www-form-urlencoded \
  ConsumptionReportInterval='' \
  DefaultChannelCreatorRoleSid='' \
  DefaultChannelRoleSid='' \
  DefaultServiceRoleSid='' \
  FriendlyName='' \
  Limits.ChannelMembers='' \
  Limits.UserChannels='' \
  Notifications.AddedToChannel.Enabled='' \
  Notifications.AddedToChannel.Template='' \
  Notifications.InvitedToChannel.Enabled='' \
  Notifications.InvitedToChannel.Template='' \
  Notifications.NewMessage.Enabled='' \
  Notifications.NewMessage.Template='' \
  Notifications.RemovedFromChannel.Enabled='' \
  Notifications.RemovedFromChannel.Template='' \
  PostWebhookUrl='' \
  PreWebhookUrl='' \
  ReachabilityEnabled='' \
  ReadStatusEnabled='' \
  TypingIndicatorTimeout='' \
  WebhookFilters='' \
  WebhookMethod='' \
  Webhooks.OnChannelAdd.Method='' \
  Webhooks.OnChannelAdd.Url='' \
  Webhooks.OnChannelAdded.Method='' \
  Webhooks.OnChannelAdded.Url='' \
  Webhooks.OnChannelDestroy.Method='' \
  Webhooks.OnChannelDestroy.Url='' \
  Webhooks.OnChannelDestroyed.Method='' \
  Webhooks.OnChannelDestroyed.Url='' \
  Webhooks.OnChannelUpdate.Method='' \
  Webhooks.OnChannelUpdate.Url='' \
  Webhooks.OnChannelUpdated.Method='' \
  Webhooks.OnChannelUpdated.Url='' \
  Webhooks.OnMemberAdd.Method='' \
  Webhooks.OnMemberAdd.Url='' \
  Webhooks.OnMemberAdded.Method='' \
  Webhooks.OnMemberAdded.Url='' \
  Webhooks.OnMemberRemove.Method='' \
  Webhooks.OnMemberRemove.Url='' \
  Webhooks.OnMemberRemoved.Method='' \
  Webhooks.OnMemberRemoved.Url='' \
  Webhooks.OnMessageRemove.Method='' \
  Webhooks.OnMessageRemove.Url='' \
  Webhooks.OnMessageRemoved.Method='' \
  Webhooks.OnMessageRemoved.Url='' \
  Webhooks.OnMessageSend.Method='' \
  Webhooks.OnMessageSend.Url='' \
  Webhooks.OnMessageSent.Method='' \
  Webhooks.OnMessageSent.Url='' \
  Webhooks.OnMessageUpdate.Method='' \
  Webhooks.OnMessageUpdate.Url='' \
  Webhooks.OnMessageUpdated.Method='' \
  Webhooks.OnMessageUpdated.Url=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'ConsumptionReportInterval=&DefaultChannelCreatorRoleSid=&DefaultChannelRoleSid=&DefaultServiceRoleSid=&FriendlyName=&Limits.ChannelMembers=&Limits.UserChannels=&Notifications.AddedToChannel.Enabled=&Notifications.AddedToChannel.Template=&Notifications.InvitedToChannel.Enabled=&Notifications.InvitedToChannel.Template=&Notifications.NewMessage.Enabled=&Notifications.NewMessage.Template=&Notifications.RemovedFromChannel.Enabled=&Notifications.RemovedFromChannel.Template=&PostWebhookUrl=&PreWebhookUrl=&ReachabilityEnabled=&ReadStatusEnabled=&TypingIndicatorTimeout=&WebhookFilters=&WebhookMethod=&Webhooks.OnChannelAdd.Method=&Webhooks.OnChannelAdd.Url=&Webhooks.OnChannelAdded.Method=&Webhooks.OnChannelAdded.Url=&Webhooks.OnChannelDestroy.Method=&Webhooks.OnChannelDestroy.Url=&Webhooks.OnChannelDestroyed.Method=&Webhooks.OnChannelDestroyed.Url=&Webhooks.OnChannelUpdate.Method=&Webhooks.OnChannelUpdate.Url=&Webhooks.OnChannelUpdated.Method=&Webhooks.OnChannelUpdated.Url=&Webhooks.OnMemberAdd.Method=&Webhooks.OnMemberAdd.Url=&Webhooks.OnMemberAdded.Method=&Webhooks.OnMemberAdded.Url=&Webhooks.OnMemberRemove.Method=&Webhooks.OnMemberRemove.Url=&Webhooks.OnMemberRemoved.Method=&Webhooks.OnMemberRemoved.Url=&Webhooks.OnMessageRemove.Method=&Webhooks.OnMessageRemove.Url=&Webhooks.OnMessageRemoved.Method=&Webhooks.OnMessageRemoved.Url=&Webhooks.OnMessageSend.Method=&Webhooks.OnMessageSend.Url=&Webhooks.OnMessageSent.Method=&Webhooks.OnMessageSent.Url=&Webhooks.OnMessageUpdate.Method=&Webhooks.OnMessageUpdate.Url=&Webhooks.OnMessageUpdated.Method=&Webhooks.OnMessageUpdated.Url=' \
  --output-document \
  - {{baseUrl}}/v1/Services/:Sid

import Foundation

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

let postData = NSMutableData(data: "ConsumptionReportInterval=".data(using: String.Encoding.utf8)!)
postData.append("&DefaultChannelCreatorRoleSid=".data(using: String.Encoding.utf8)!)
postData.append("&DefaultChannelRoleSid=".data(using: String.Encoding.utf8)!)
postData.append("&DefaultServiceRoleSid=".data(using: String.Encoding.utf8)!)
postData.append("&FriendlyName=".data(using: String.Encoding.utf8)!)
postData.append("&Limits.ChannelMembers=".data(using: String.Encoding.utf8)!)
postData.append("&Limits.UserChannels=".data(using: String.Encoding.utf8)!)
postData.append("&Notifications.AddedToChannel.Enabled=".data(using: String.Encoding.utf8)!)
postData.append("&Notifications.AddedToChannel.Template=".data(using: String.Encoding.utf8)!)
postData.append("&Notifications.InvitedToChannel.Enabled=".data(using: String.Encoding.utf8)!)
postData.append("&Notifications.InvitedToChannel.Template=".data(using: String.Encoding.utf8)!)
postData.append("&Notifications.NewMessage.Enabled=".data(using: String.Encoding.utf8)!)
postData.append("&Notifications.NewMessage.Template=".data(using: String.Encoding.utf8)!)
postData.append("&Notifications.RemovedFromChannel.Enabled=".data(using: String.Encoding.utf8)!)
postData.append("&Notifications.RemovedFromChannel.Template=".data(using: String.Encoding.utf8)!)
postData.append("&PostWebhookUrl=".data(using: String.Encoding.utf8)!)
postData.append("&PreWebhookUrl=".data(using: String.Encoding.utf8)!)
postData.append("&ReachabilityEnabled=".data(using: String.Encoding.utf8)!)
postData.append("&ReadStatusEnabled=".data(using: String.Encoding.utf8)!)
postData.append("&TypingIndicatorTimeout=".data(using: String.Encoding.utf8)!)
postData.append("&WebhookFilters=".data(using: String.Encoding.utf8)!)
postData.append("&WebhookMethod=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelAdd.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelAdd.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelAdded.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelAdded.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelDestroy.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelDestroy.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelDestroyed.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelDestroyed.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelUpdate.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelUpdate.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelUpdated.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnChannelUpdated.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMemberAdd.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMemberAdd.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMemberAdded.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMemberAdded.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMemberRemove.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMemberRemove.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMemberRemoved.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMemberRemoved.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageRemove.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageRemove.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageRemoved.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageRemoved.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageSend.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageSend.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageSent.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageSent.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageUpdate.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageUpdate.Url=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageUpdated.Method=".data(using: String.Encoding.utf8)!)
postData.append("&Webhooks.OnMessageUpdated.Url=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/Services/: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 UpdateUser

{{baseUrl}}/v1/Services/:ServiceSid/Users/:Sid

QUERY PARAMS

ServiceSid

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/:ServiceSid/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/:ServiceSid/Users/:Sid" {:form-params {:Attributes ""
                                                                                             :FriendlyName ""
                                                                                             :RoleSid ""}})

require "http/client"

url = "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Users/:Sid', [
  'form_params' => [
    'Attributes' => '',
    'FriendlyName' => '',
    'RoleSid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Users/:Sid", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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/:ServiceSid/Users/:Sid \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data Attributes= \
  --data FriendlyName= \
  --data RoleSid=

http --form POST {{baseUrl}}/v1/Services/:ServiceSid/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/:ServiceSid/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/:ServiceSid/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()