kaizala-docs

POST Generate One-Time PIN

{{baseUrl}}/generatePin

HEADERS

Content-Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/generatePin" {:headers {:content-type ""}})

require "http/client"

url = "{{baseUrl}}/generatePin"
headers = HTTP::Headers{
  "content-type" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/generatePin");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/generatePin"

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

	req.Header.Add("content-type", "")

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

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

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

}

POST /baseUrl/generatePin HTTP/1.1
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/generatePin")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/generatePin"))
    .header("content-type", "")
    .method("POST", 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}}/generatePin")
  .post(null)
  .addHeader("content-type", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/generatePin")
  .header("content-type", "")
  .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('POST', '{{baseUrl}}/generatePin');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/generatePin',
  headers: {'content-type': ''}
};

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

const url = '{{baseUrl}}/generatePin';
const options = {method: 'POST', headers: {'content-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}}/generatePin',
  method: 'POST',
  headers: {
    'content-type': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/generatePin")
  .post(null)
  .addHeader("content-type", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/generatePin',
  headers: {
    'content-type': ''
  }
};

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: 'POST',
  url: '{{baseUrl}}/generatePin',
  headers: {'content-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}}/generatePin');

req.headers({
  'content-type': ''
});

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

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

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/generatePin',
  headers: {'content-type': ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/generatePin';
const options = {method: 'POST', headers: {'content-type': ''}};

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": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/generatePin"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/generatePin" in
let headers = Header.add (Header.init ()) "content-type" "" in

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

 "{{baseUrl}}/generatePin",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/generatePin', [
  'headers' => [
    'content-type' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'content-type' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/generatePin');
$request->setRequestMethod('POST');
$request->setHeaders([
  'content-type' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/generatePin' -Method POST -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/generatePin' -Method POST -Headers $headers

import http.client

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

headers = { 'content-type': "" }

conn.request("POST", "/baseUrl/generatePin", headers=headers)

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

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

import requests

url = "{{baseUrl}}/generatePin"

headers = {"content-type": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/generatePin"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/generatePin")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/generatePin') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/generatePin \
  --header 'content-type: '

http POST {{baseUrl}}/generatePin \
  content-type:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --output-document \
  - {{baseUrl}}/generatePin

import Foundation

let headers = ["content-type": ""]

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

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 Login with pin and applicationId to get refresh token

{{baseUrl}}/loginWithPinAndApplicationId

HEADERS

Content-Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/loginWithPinAndApplicationId" {:headers {:content-type ""}})

require "http/client"

url = "{{baseUrl}}/loginWithPinAndApplicationId"
headers = HTTP::Headers{
  "content-type" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/loginWithPinAndApplicationId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/loginWithPinAndApplicationId"

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

	req.Header.Add("content-type", "")

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

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

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

}

POST /baseUrl/loginWithPinAndApplicationId HTTP/1.1
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/loginWithPinAndApplicationId")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/loginWithPinAndApplicationId"))
    .header("content-type", "")
    .method("POST", 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}}/loginWithPinAndApplicationId")
  .post(null)
  .addHeader("content-type", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/loginWithPinAndApplicationId")
  .header("content-type", "")
  .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('POST', '{{baseUrl}}/loginWithPinAndApplicationId');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/loginWithPinAndApplicationId',
  headers: {'content-type': ''}
};

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

const url = '{{baseUrl}}/loginWithPinAndApplicationId';
const options = {method: 'POST', headers: {'content-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}}/loginWithPinAndApplicationId',
  method: 'POST',
  headers: {
    'content-type': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/loginWithPinAndApplicationId")
  .post(null)
  .addHeader("content-type", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/loginWithPinAndApplicationId',
  headers: {
    'content-type': ''
  }
};

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: 'POST',
  url: '{{baseUrl}}/loginWithPinAndApplicationId',
  headers: {'content-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}}/loginWithPinAndApplicationId');

req.headers({
  'content-type': ''
});

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

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

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/loginWithPinAndApplicationId',
  headers: {'content-type': ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/loginWithPinAndApplicationId';
const options = {method: 'POST', headers: {'content-type': ''}};

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": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/loginWithPinAndApplicationId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/loginWithPinAndApplicationId" in
let headers = Header.add (Header.init ()) "content-type" "" in

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

 "{{baseUrl}}/loginWithPinAndApplicationId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/loginWithPinAndApplicationId', [
  'headers' => [
    'content-type' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'content-type' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/loginWithPinAndApplicationId');
$request->setRequestMethod('POST');
$request->setHeaders([
  'content-type' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/loginWithPinAndApplicationId' -Method POST -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/loginWithPinAndApplicationId' -Method POST -Headers $headers

import http.client

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

headers = { 'content-type': "" }

conn.request("POST", "/baseUrl/loginWithPinAndApplicationId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/loginWithPinAndApplicationId"

headers = {"content-type": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/loginWithPinAndApplicationId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/loginWithPinAndApplicationId")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/loginWithPinAndApplicationId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/loginWithPinAndApplicationId \
  --header 'content-type: '

http POST {{baseUrl}}/loginWithPinAndApplicationId \
  content-type:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --output-document \
  - {{baseUrl}}/loginWithPinAndApplicationId

import Foundation

let headers = ["content-type": ""]

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

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 Retrieve the access token

{{baseUrl}}/accessToken

HEADERS

applicationId

applicationSecret

refreshToken

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accessToken");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "applicationid: ");
headers = curl_slist_append(headers, "applicationsecret: ");
headers = curl_slist_append(headers, "refreshtoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/accessToken" {:headers {:applicationid ""
                                                                 :applicationsecret ""
                                                                 :refreshtoken ""}})

require "http/client"

url = "{{baseUrl}}/accessToken"
headers = HTTP::Headers{
  "applicationid" => ""
  "applicationsecret" => ""
  "refreshtoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/accessToken"),
    Headers =
    {
        { "applicationid", "" },
        { "applicationsecret", "" },
        { "refreshtoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accessToken");
var request = new RestRequest("", Method.Get);
request.AddHeader("applicationid", "");
request.AddHeader("applicationsecret", "");
request.AddHeader("refreshtoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accessToken"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("applicationid", "")
	req.Header.Add("applicationsecret", "")
	req.Header.Add("refreshtoken", "")

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

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

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

}

GET /baseUrl/accessToken HTTP/1.1
Applicationid: 
Applicationsecret: 
Refreshtoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accessToken")
  .setHeader("applicationid", "")
  .setHeader("applicationsecret", "")
  .setHeader("refreshtoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accessToken"))
    .header("applicationid", "")
    .header("applicationsecret", "")
    .header("refreshtoken", "")
    .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}}/accessToken")
  .get()
  .addHeader("applicationid", "")
  .addHeader("applicationsecret", "")
  .addHeader("refreshtoken", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/accessToken")
  .header("applicationid", "")
  .header("applicationsecret", "")
  .header("refreshtoken", "")
  .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}}/accessToken');
xhr.setRequestHeader('applicationid', '');
xhr.setRequestHeader('applicationsecret', '');
xhr.setRequestHeader('refreshtoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accessToken',
  headers: {applicationid: '', applicationsecret: '', refreshtoken: ''}
};

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

const url = '{{baseUrl}}/accessToken';
const options = {
  method: 'GET',
  headers: {applicationid: '', applicationsecret: '', refreshtoken: ''}
};

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}}/accessToken',
  method: 'GET',
  headers: {
    applicationid: '',
    applicationsecret: '',
    refreshtoken: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accessToken")
  .get()
  .addHeader("applicationid", "")
  .addHeader("applicationsecret", "")
  .addHeader("refreshtoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accessToken',
  headers: {
    applicationid: '',
    applicationsecret: '',
    refreshtoken: ''
  }
};

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}}/accessToken',
  headers: {applicationid: '', applicationsecret: '', refreshtoken: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accessToken');

req.headers({
  applicationid: '',
  applicationsecret: '',
  refreshtoken: ''
});

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}}/accessToken',
  headers: {applicationid: '', applicationsecret: '', refreshtoken: ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/accessToken';
const options = {
  method: 'GET',
  headers: {applicationid: '', applicationsecret: '', refreshtoken: ''}
};

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

#import 

NSDictionary *headers = @{ @"applicationid": @"",
                           @"applicationsecret": @"",
                           @"refreshtoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accessToken"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/accessToken" in
let headers = Header.add_list (Header.init ()) [
  ("applicationid", "");
  ("applicationsecret", "");
  ("refreshtoken", "");
] in

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

 "{{baseUrl}}/accessToken",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "applicationid: ",
    "applicationsecret: ",
    "refreshtoken: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/accessToken', [
  'headers' => [
    'applicationid' => '',
    'applicationsecret' => '',
    'refreshtoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accessToken');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'applicationid' => '',
  'applicationsecret' => '',
  'refreshtoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/accessToken');
$request->setRequestMethod('GET');
$request->setHeaders([
  'applicationid' => '',
  'applicationsecret' => '',
  'refreshtoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("applicationid", "")
$headers.Add("applicationsecret", "")
$headers.Add("refreshtoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/accessToken' -Method GET -Headers $headers

$headers=@{}
$headers.Add("applicationid", "")
$headers.Add("applicationsecret", "")
$headers.Add("refreshtoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accessToken' -Method GET -Headers $headers

import http.client

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

headers = {
    'applicationid': "",
    'applicationsecret': "",
    'refreshtoken': ""
}

conn.request("GET", "/baseUrl/accessToken", headers=headers)

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

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

import requests

url = "{{baseUrl}}/accessToken"

headers = {
    "applicationid": "",
    "applicationsecret": "",
    "refreshtoken": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accessToken"

response <- VERB("GET", url, add_headers('applicationid' = '', 'applicationsecret' = '', 'refreshtoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accessToken")

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

request = Net::HTTP::Get.new(url)
request["applicationid"] = ''
request["applicationsecret"] = ''
request["refreshtoken"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/accessToken') do |req|
  req.headers['applicationid'] = ''
  req.headers['applicationsecret'] = ''
  req.headers['refreshtoken'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("applicationid", "".parse().unwrap());
    headers.insert("applicationsecret", "".parse().unwrap());
    headers.insert("refreshtoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/accessToken \
  --header 'applicationid: ' \
  --header 'applicationsecret: ' \
  --header 'refreshtoken: '

http GET {{baseUrl}}/accessToken \
  applicationid:'' \
  applicationsecret:'' \
  refreshtoken:''

wget --quiet \
  --method GET \
  --header 'applicationid: ' \
  --header 'applicationsecret: ' \
  --header 'refreshtoken: ' \
  --output-document \
  - {{baseUrl}}/accessToken

import Foundation

let headers = [
  "applicationid": "",
  "applicationsecret": "",
  "refreshtoken": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accessToken")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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 Post custom action to subscriber(s) in a public group

{{baseUrl}}/groups/:test-public-group-id/actions

HEADERS

accessToken

Content-Type

QUERY PARAMS

test-public-group-id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:test-public-group-id/actions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/groups/:test-public-group-id/actions" {:headers {:accesstoken ""
                                                                                           :content-type ""}})

require "http/client"

url = "{{baseUrl}}/groups/:test-public-group-id/actions"
headers = HTTP::Headers{
  "accesstoken" => ""
  "content-type" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/groups/:test-public-group-id/actions"),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/:test-public-group-id/actions");
var request = new RestRequest("", Method.Post);
request.AddHeader("accesstoken", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups/:test-public-group-id/actions"

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

	req.Header.Add("accesstoken", "")
	req.Header.Add("content-type", "")

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

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

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

}

POST /baseUrl/groups/:test-public-group-id/actions HTTP/1.1
Accesstoken: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/groups/:test-public-group-id/actions")
  .setHeader("accesstoken", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:test-public-group-id/actions"))
    .header("accesstoken", "")
    .header("content-type", "")
    .method("POST", 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}}/groups/:test-public-group-id/actions")
  .post(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/groups/:test-public-group-id/actions")
  .header("accesstoken", "")
  .header("content-type", "")
  .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('POST', '{{baseUrl}}/groups/:test-public-group-id/actions');
xhr.setRequestHeader('accesstoken', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups/:test-public-group-id/actions',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const url = '{{baseUrl}}/groups/:test-public-group-id/actions';
const options = {method: 'POST', headers: {accesstoken: '', 'content-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}}/groups/:test-public-group-id/actions',
  method: 'POST',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:test-public-group-id/actions")
  .post(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:test-public-group-id/actions',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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: 'POST',
  url: '{{baseUrl}}/groups/:test-public-group-id/actions',
  headers: {accesstoken: '', 'content-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}}/groups/:test-public-group-id/actions');

req.headers({
  accesstoken: '',
  'content-type': ''
});

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

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

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups/:test-public-group-id/actions',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:test-public-group-id/actions';
const options = {method: 'POST', headers: {accesstoken: '', 'content-type': ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:test-public-group-id/actions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:test-public-group-id/actions" in
let headers = Header.add_list (Header.init ()) [
  ("accesstoken", "");
  ("content-type", "");
] in

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

 "{{baseUrl}}/groups/:test-public-group-id/actions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "accesstoken: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/groups/:test-public-group-id/actions', [
  'headers' => [
    'accesstoken' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/groups/:test-public-group-id/actions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups/:test-public-group-id/actions');
$request->setRequestMethod('POST');
$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:test-public-group-id/actions' -Method POST -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:test-public-group-id/actions' -Method POST -Headers $headers

import http.client

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

headers = {
    'accesstoken': "",
    'content-type': ""
}

conn.request("POST", "/baseUrl/groups/:test-public-group-id/actions", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups/:test-public-group-id/actions"

headers = {
    "accesstoken": "",
    "content-type": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/:test-public-group-id/actions"

response <- VERB("POST", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:test-public-group-id/actions")

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

request = Net::HTTP::Post.new(url)
request["accesstoken"] = ''
request["content-type"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/groups/:test-public-group-id/actions') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:test-public-group-id/actions";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/groups/:test-public-group-id/actions \
  --header 'accesstoken: ' \
  --header 'content-type: '

http POST {{baseUrl}}/groups/:test-public-group-id/actions \
  accesstoken:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'accesstoken: ' \
  --header 'content-type: ' \
  --output-document \
  - {{baseUrl}}/groups/:test-public-group-id/actions

import Foundation

let headers = [
  "accesstoken": "",
  "content-type": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:test-public-group-id/actions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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 Posting a response to a survey

{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses

HEADERS

Content-Type

accessToken

QUERY PARAMS

test-group-id

test-survey-id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
headers = curl_slist_append(headers, "accesstoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses" {:headers {:content-type ""
                                                                                                              :accesstoken ""}})

require "http/client"

url = "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses"
headers = HTTP::Headers{
  "content-type" => ""
  "accesstoken" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses"),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
request.AddHeader("accesstoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses"

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

	req.Header.Add("content-type", "")
	req.Header.Add("accesstoken", "")

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

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

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

}

POST /baseUrl/groups/:test-group-id/actions/:test-survey-id/responses HTTP/1.1
Content-Type: 
Accesstoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses")
  .setHeader("content-type", "")
  .setHeader("accesstoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses"))
    .header("content-type", "")
    .header("accesstoken", "")
    .method("POST", 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}}/groups/:test-group-id/actions/:test-survey-id/responses")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accesstoken", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses")
  .header("content-type", "")
  .header("accesstoken", "")
  .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('POST', '{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accesstoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses',
  headers: {'content-type': '', accesstoken: ''}
};

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

const url = '{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses';
const options = {method: 'POST', headers: {'content-type': '', accesstoken: ''}};

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}}/groups/:test-group-id/actions/:test-survey-id/responses',
  method: 'POST',
  headers: {
    'content-type': '',
    accesstoken: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accesstoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:test-group-id/actions/:test-survey-id/responses',
  headers: {
    'content-type': '',
    accesstoken: ''
  }
};

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: 'POST',
  url: '{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses',
  headers: {'content-type': '', accesstoken: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses');

req.headers({
  'content-type': '',
  accesstoken: ''
});

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

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

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses',
  headers: {'content-type': '', accesstoken: ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses';
const options = {method: 'POST', headers: {'content-type': '', accesstoken: ''}};

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": @"",
                           @"accesstoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accesstoken", "");
] in

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

 "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "accesstoken: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses', [
  'headers' => [
    'accesstoken' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => '',
  'accesstoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses');
$request->setRequestMethod('POST');
$request->setHeaders([
  'content-type' => '',
  'accesstoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accesstoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses' -Method POST -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accesstoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses' -Method POST -Headers $headers

import http.client

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

headers = {
    'content-type': "",
    'accesstoken': ""
}

conn.request("POST", "/baseUrl/groups/:test-group-id/actions/:test-survey-id/responses", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses"

headers = {
    "content-type": "",
    "accesstoken": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses"

response <- VERB("POST", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = ''
request["accesstoken"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/groups/:test-group-id/actions/:test-survey-id/responses') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accesstoken", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses \
  --header 'accesstoken: ' \
  --header 'content-type: '

http POST {{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses \
  accesstoken:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --header 'accesstoken: ' \
  --output-document \
  - {{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses

import Foundation

let headers = [
  "content-type": "",
  "accesstoken": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id/responses")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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 Posting a response to an action

{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses

HEADERS

Content-Type

accessToken

QUERY PARAMS

test-group-id

test-action-id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
headers = curl_slist_append(headers, "accesstoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses" {:headers {:content-type ""
                                                                                                              :accesstoken ""}})

require "http/client"

url = "{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses"
headers = HTTP::Headers{
  "content-type" => ""
  "accesstoken" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses"),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
request.AddHeader("accesstoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses"

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

	req.Header.Add("content-type", "")
	req.Header.Add("accesstoken", "")

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

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

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

}

POST /baseUrl/groups/:test-group-id/actions/:test-action-id/responses HTTP/1.1
Content-Type: 
Accesstoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses")
  .setHeader("content-type", "")
  .setHeader("accesstoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses"))
    .header("content-type", "")
    .header("accesstoken", "")
    .method("POST", 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}}/groups/:test-group-id/actions/:test-action-id/responses")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accesstoken", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses")
  .header("content-type", "")
  .header("accesstoken", "")
  .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('POST', '{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accesstoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses',
  headers: {'content-type': '', accesstoken: ''}
};

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

const url = '{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses';
const options = {method: 'POST', headers: {'content-type': '', accesstoken: ''}};

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}}/groups/:test-group-id/actions/:test-action-id/responses',
  method: 'POST',
  headers: {
    'content-type': '',
    accesstoken: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accesstoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:test-group-id/actions/:test-action-id/responses',
  headers: {
    'content-type': '',
    accesstoken: ''
  }
};

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: 'POST',
  url: '{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses',
  headers: {'content-type': '', accesstoken: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses');

req.headers({
  'content-type': '',
  accesstoken: ''
});

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

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

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses',
  headers: {'content-type': '', accesstoken: ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses';
const options = {method: 'POST', headers: {'content-type': '', accesstoken: ''}};

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": @"",
                           @"accesstoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accesstoken", "");
] in

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

 "{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "accesstoken: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses', [
  'headers' => [
    'accesstoken' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => '',
  'accesstoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses');
$request->setRequestMethod('POST');
$request->setHeaders([
  'content-type' => '',
  'accesstoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accesstoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses' -Method POST -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accesstoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses' -Method POST -Headers $headers

import http.client

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

headers = {
    'content-type': "",
    'accesstoken': ""
}

conn.request("POST", "/baseUrl/groups/:test-group-id/actions/:test-action-id/responses", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses"

headers = {
    "content-type": "",
    "accesstoken": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses"

response <- VERB("POST", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = ''
request["accesstoken"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/groups/:test-group-id/actions/:test-action-id/responses') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accesstoken", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses \
  --header 'accesstoken: ' \
  --header 'content-type: '

http POST {{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses \
  accesstoken:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --header 'accesstoken: ' \
  --output-document \
  - {{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses

import Foundation

let headers = [
  "content-type": "",
  "accesstoken": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:test-group-id/actions/:test-action-id/responses")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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 Send message on a group

{{baseUrl}}/groups/:test-group-id/messages

HEADERS

accessToken

Content-Type

QUERY PARAMS

test-group-id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:test-group-id/messages");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/groups/:test-group-id/messages" {:headers {:accesstoken ""
                                                                                     :content-type ""}})

require "http/client"

url = "{{baseUrl}}/groups/:test-group-id/messages"
headers = HTTP::Headers{
  "accesstoken" => ""
  "content-type" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/groups/:test-group-id/messages"),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/:test-group-id/messages");
var request = new RestRequest("", Method.Post);
request.AddHeader("accesstoken", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups/:test-group-id/messages"

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

	req.Header.Add("accesstoken", "")
	req.Header.Add("content-type", "")

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

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

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

}

POST /baseUrl/groups/:test-group-id/messages HTTP/1.1
Accesstoken: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/groups/:test-group-id/messages")
  .setHeader("accesstoken", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:test-group-id/messages"))
    .header("accesstoken", "")
    .header("content-type", "")
    .method("POST", 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}}/groups/:test-group-id/messages")
  .post(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/groups/:test-group-id/messages")
  .header("accesstoken", "")
  .header("content-type", "")
  .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('POST', '{{baseUrl}}/groups/:test-group-id/messages');
xhr.setRequestHeader('accesstoken', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups/:test-group-id/messages',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const url = '{{baseUrl}}/groups/:test-group-id/messages';
const options = {method: 'POST', headers: {accesstoken: '', 'content-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}}/groups/:test-group-id/messages',
  method: 'POST',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:test-group-id/messages")
  .post(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:test-group-id/messages',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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: 'POST',
  url: '{{baseUrl}}/groups/:test-group-id/messages',
  headers: {accesstoken: '', 'content-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}}/groups/:test-group-id/messages');

req.headers({
  accesstoken: '',
  'content-type': ''
});

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

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

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups/:test-group-id/messages',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:test-group-id/messages';
const options = {method: 'POST', headers: {accesstoken: '', 'content-type': ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:test-group-id/messages"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:test-group-id/messages" in
let headers = Header.add_list (Header.init ()) [
  ("accesstoken", "");
  ("content-type", "");
] in

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

 "{{baseUrl}}/groups/:test-group-id/messages",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "accesstoken: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/groups/:test-group-id/messages', [
  'headers' => [
    'accesstoken' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/groups/:test-group-id/messages');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups/:test-group-id/messages');
$request->setRequestMethod('POST');
$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:test-group-id/messages' -Method POST -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:test-group-id/messages' -Method POST -Headers $headers

import http.client

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

headers = {
    'accesstoken': "",
    'content-type': ""
}

conn.request("POST", "/baseUrl/groups/:test-group-id/messages", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups/:test-group-id/messages"

headers = {
    "accesstoken": "",
    "content-type": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/:test-group-id/messages"

response <- VERB("POST", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:test-group-id/messages")

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

request = Net::HTTP::Post.new(url)
request["accesstoken"] = ''
request["content-type"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/groups/:test-group-id/messages') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:test-group-id/messages";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/groups/:test-group-id/messages \
  --header 'accesstoken: ' \
  --header 'content-type: '

http POST {{baseUrl}}/groups/:test-group-id/messages \
  accesstoken:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'accesstoken: ' \
  --header 'content-type: ' \
  --output-document \
  - {{baseUrl}}/groups/:test-group-id/messages

import Foundation

let headers = [
  "accesstoken": "",
  "content-type": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:test-group-id/messages")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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 Send message to subscriber(s) in a public group

{{baseUrl}}/groups/:test-public-group-id/messages

HEADERS

accessToken

Content-Type

QUERY PARAMS

test-public-group-id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:test-public-group-id/messages");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/groups/:test-public-group-id/messages" {:headers {:accesstoken ""
                                                                                            :content-type ""}})

require "http/client"

url = "{{baseUrl}}/groups/:test-public-group-id/messages"
headers = HTTP::Headers{
  "accesstoken" => ""
  "content-type" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/groups/:test-public-group-id/messages"),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/:test-public-group-id/messages");
var request = new RestRequest("", Method.Post);
request.AddHeader("accesstoken", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups/:test-public-group-id/messages"

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

	req.Header.Add("accesstoken", "")
	req.Header.Add("content-type", "")

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

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

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

}

POST /baseUrl/groups/:test-public-group-id/messages HTTP/1.1
Accesstoken: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/groups/:test-public-group-id/messages")
  .setHeader("accesstoken", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:test-public-group-id/messages"))
    .header("accesstoken", "")
    .header("content-type", "")
    .method("POST", 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}}/groups/:test-public-group-id/messages")
  .post(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/groups/:test-public-group-id/messages")
  .header("accesstoken", "")
  .header("content-type", "")
  .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('POST', '{{baseUrl}}/groups/:test-public-group-id/messages');
xhr.setRequestHeader('accesstoken', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups/:test-public-group-id/messages',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const url = '{{baseUrl}}/groups/:test-public-group-id/messages';
const options = {method: 'POST', headers: {accesstoken: '', 'content-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}}/groups/:test-public-group-id/messages',
  method: 'POST',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:test-public-group-id/messages")
  .post(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:test-public-group-id/messages',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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: 'POST',
  url: '{{baseUrl}}/groups/:test-public-group-id/messages',
  headers: {accesstoken: '', 'content-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}}/groups/:test-public-group-id/messages');

req.headers({
  accesstoken: '',
  'content-type': ''
});

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

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

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups/:test-public-group-id/messages',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:test-public-group-id/messages';
const options = {method: 'POST', headers: {accesstoken: '', 'content-type': ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:test-public-group-id/messages"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:test-public-group-id/messages" in
let headers = Header.add_list (Header.init ()) [
  ("accesstoken", "");
  ("content-type", "");
] in

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

 "{{baseUrl}}/groups/:test-public-group-id/messages",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "accesstoken: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/groups/:test-public-group-id/messages', [
  'headers' => [
    'accesstoken' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/groups/:test-public-group-id/messages');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups/:test-public-group-id/messages');
$request->setRequestMethod('POST');
$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:test-public-group-id/messages' -Method POST -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:test-public-group-id/messages' -Method POST -Headers $headers

import http.client

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

headers = {
    'accesstoken': "",
    'content-type': ""
}

conn.request("POST", "/baseUrl/groups/:test-public-group-id/messages", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups/:test-public-group-id/messages"

headers = {
    "accesstoken": "",
    "content-type": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/:test-public-group-id/messages"

response <- VERB("POST", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:test-public-group-id/messages")

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

request = Net::HTTP::Post.new(url)
request["accesstoken"] = ''
request["content-type"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/groups/:test-public-group-id/messages') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:test-public-group-id/messages";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/groups/:test-public-group-id/messages \
  --header 'accesstoken: ' \
  --header 'content-type: '

http POST {{baseUrl}}/groups/:test-public-group-id/messages \
  accesstoken:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'accesstoken: ' \
  --header 'content-type: ' \
  --output-document \
  - {{baseUrl}}/groups/:test-public-group-id/messages

import Foundation

let headers = [
  "accesstoken": "",
  "content-type": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:test-public-group-id/messages")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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 Send survey on a group

{{baseUrl}}/groups/:test-group-id/actions

HEADERS

Content-Type

accessToken

QUERY PARAMS

test-group-id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:test-group-id/actions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
headers = curl_slist_append(headers, "accesstoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/groups/:test-group-id/actions" {:headers {:content-type ""
                                                                                    :accesstoken ""}})

require "http/client"

url = "{{baseUrl}}/groups/:test-group-id/actions"
headers = HTTP::Headers{
  "content-type" => ""
  "accesstoken" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/groups/:test-group-id/actions"),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/:test-group-id/actions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
request.AddHeader("accesstoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups/:test-group-id/actions"

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

	req.Header.Add("content-type", "")
	req.Header.Add("accesstoken", "")

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

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

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

}

POST /baseUrl/groups/:test-group-id/actions HTTP/1.1
Content-Type: 
Accesstoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/groups/:test-group-id/actions")
  .setHeader("content-type", "")
  .setHeader("accesstoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:test-group-id/actions"))
    .header("content-type", "")
    .header("accesstoken", "")
    .method("POST", 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}}/groups/:test-group-id/actions")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accesstoken", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/groups/:test-group-id/actions")
  .header("content-type", "")
  .header("accesstoken", "")
  .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('POST', '{{baseUrl}}/groups/:test-group-id/actions');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accesstoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups/:test-group-id/actions',
  headers: {'content-type': '', accesstoken: ''}
};

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

const url = '{{baseUrl}}/groups/:test-group-id/actions';
const options = {method: 'POST', headers: {'content-type': '', accesstoken: ''}};

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}}/groups/:test-group-id/actions',
  method: 'POST',
  headers: {
    'content-type': '',
    accesstoken: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:test-group-id/actions")
  .post(null)
  .addHeader("content-type", "")
  .addHeader("accesstoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:test-group-id/actions',
  headers: {
    'content-type': '',
    accesstoken: ''
  }
};

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: 'POST',
  url: '{{baseUrl}}/groups/:test-group-id/actions',
  headers: {'content-type': '', accesstoken: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/groups/:test-group-id/actions');

req.headers({
  'content-type': '',
  accesstoken: ''
});

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

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

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups/:test-group-id/actions',
  headers: {'content-type': '', accesstoken: ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:test-group-id/actions';
const options = {method: 'POST', headers: {'content-type': '', accesstoken: ''}};

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": @"",
                           @"accesstoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:test-group-id/actions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:test-group-id/actions" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accesstoken", "");
] in

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

 "{{baseUrl}}/groups/:test-group-id/actions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "accesstoken: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/groups/:test-group-id/actions', [
  'headers' => [
    'accesstoken' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/groups/:test-group-id/actions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => '',
  'accesstoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups/:test-group-id/actions');
$request->setRequestMethod('POST');
$request->setHeaders([
  'content-type' => '',
  'accesstoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accesstoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:test-group-id/actions' -Method POST -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accesstoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:test-group-id/actions' -Method POST -Headers $headers

import http.client

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

headers = {
    'content-type': "",
    'accesstoken': ""
}

conn.request("POST", "/baseUrl/groups/:test-group-id/actions", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups/:test-group-id/actions"

headers = {
    "content-type": "",
    "accesstoken": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/:test-group-id/actions"

response <- VERB("POST", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:test-group-id/actions")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = ''
request["accesstoken"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/groups/:test-group-id/actions') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:test-group-id/actions";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accesstoken", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/groups/:test-group-id/actions \
  --header 'accesstoken: ' \
  --header 'content-type: '

http POST {{baseUrl}}/groups/:test-group-id/actions \
  accesstoken:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --header 'accesstoken: ' \
  --output-document \
  - {{baseUrl}}/groups/:test-group-id/actions

import Foundation

let headers = [
  "content-type": "",
  "accesstoken": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:test-group-id/actions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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 Upload media

{{baseUrl}}/media

HEADERS

accessToken

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/media" {:headers {:accesstoken ""}})

require "http/client"

url = "{{baseUrl}}/media"
headers = HTTP::Headers{
  "accesstoken" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/media");
var request = new RestRequest("", Method.Post);
request.AddHeader("accesstoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/media"

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

	req.Header.Add("accesstoken", "")

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

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

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

}

POST /baseUrl/media HTTP/1.1
Accesstoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/media")
  .setHeader("accesstoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/media"))
    .header("accesstoken", "")
    .method("POST", 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}}/media")
  .post(null)
  .addHeader("accesstoken", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/media")
  .header("accesstoken", "")
  .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('POST', '{{baseUrl}}/media');
xhr.setRequestHeader('accesstoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/media',
  headers: {accesstoken: ''}
};

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

const url = '{{baseUrl}}/media';
const options = {method: 'POST', headers: {accesstoken: ''}};

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}}/media',
  method: 'POST',
  headers: {
    accesstoken: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/media")
  .post(null)
  .addHeader("accesstoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/media',
  headers: {
    accesstoken: ''
  }
};

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: 'POST',
  url: '{{baseUrl}}/media',
  headers: {accesstoken: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  accesstoken: ''
});

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

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

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/media',
  headers: {accesstoken: ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/media';
const options = {method: 'POST', headers: {accesstoken: ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/media"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/media" in
let headers = Header.add (Header.init ()) "accesstoken" "" in

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

 "{{baseUrl}}/media",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "accesstoken: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/media', [
  'headers' => [
    'accesstoken' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'accesstoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/media');
$request->setRequestMethod('POST');
$request->setHeaders([
  'accesstoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/media' -Method POST -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/media' -Method POST -Headers $headers

import http.client

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

headers = { 'accesstoken': "" }

conn.request("POST", "/baseUrl/media", headers=headers)

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

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

import requests

url = "{{baseUrl}}/media"

headers = {"accesstoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/media"

response <- VERB("POST", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/media")

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

request = Net::HTTP::Post.new(url)
request["accesstoken"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/media') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/media \
  --header 'accesstoken: '

http POST {{baseUrl}}/media \
  accesstoken:''

wget --quiet \
  --method POST \
  --header 'accesstoken: ' \
  --output-document \
  - {{baseUrl}}/media

import Foundation

let headers = ["accesstoken": ""]

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

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 Fetch jobs in a group

{{baseUrl}}/groups/:test-group-id/actions

HEADERS

accessToken

QUERY PARAMS

actionType

test-group-id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:test-group-id/actions?actionType=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/groups/:test-group-id/actions" {:headers {:accesstoken ""}
                                                                         :query-params {:actionType ""}})

require "http/client"

url = "{{baseUrl}}/groups/:test-group-id/actions?actionType="
headers = HTTP::Headers{
  "accesstoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/groups/:test-group-id/actions?actionType="),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/:test-group-id/actions?actionType=");
var request = new RestRequest("", Method.Get);
request.AddHeader("accesstoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups/:test-group-id/actions?actionType="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accesstoken", "")

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

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

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

}

GET /baseUrl/groups/:test-group-id/actions?actionType= HTTP/1.1
Accesstoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/groups/:test-group-id/actions?actionType=")
  .setHeader("accesstoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:test-group-id/actions?actionType="))
    .header("accesstoken", "")
    .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}}/groups/:test-group-id/actions?actionType=")
  .get()
  .addHeader("accesstoken", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/groups/:test-group-id/actions?actionType=")
  .header("accesstoken", "")
  .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}}/groups/:test-group-id/actions?actionType=');
xhr.setRequestHeader('accesstoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/groups/:test-group-id/actions',
  params: {actionType: ''},
  headers: {accesstoken: ''}
};

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

const url = '{{baseUrl}}/groups/:test-group-id/actions?actionType=';
const options = {method: 'GET', headers: {accesstoken: ''}};

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}}/groups/:test-group-id/actions?actionType=',
  method: 'GET',
  headers: {
    accesstoken: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:test-group-id/actions?actionType=")
  .get()
  .addHeader("accesstoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:test-group-id/actions?actionType=',
  headers: {
    accesstoken: ''
  }
};

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}}/groups/:test-group-id/actions',
  qs: {actionType: ''},
  headers: {accesstoken: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/groups/:test-group-id/actions');

req.query({
  actionType: ''
});

req.headers({
  accesstoken: ''
});

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}}/groups/:test-group-id/actions',
  params: {actionType: ''},
  headers: {accesstoken: ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:test-group-id/actions?actionType=';
const options = {method: 'GET', headers: {accesstoken: ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:test-group-id/actions?actionType="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:test-group-id/actions?actionType=" in
let headers = Header.add (Header.init ()) "accesstoken" "" in

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

 "{{baseUrl}}/groups/:test-group-id/actions?actionType=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accesstoken: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/groups/:test-group-id/actions?actionType=', [
  'headers' => [
    'accesstoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/groups/:test-group-id/actions');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'actionType' => ''
]);

$request->setHeaders([
  'accesstoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups/:test-group-id/actions');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'actionType' => ''
]));

$request->setHeaders([
  'accesstoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:test-group-id/actions?actionType=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:test-group-id/actions?actionType=' -Method GET -Headers $headers

import http.client

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

headers = { 'accesstoken': "" }

conn.request("GET", "/baseUrl/groups/:test-group-id/actions?actionType=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups/:test-group-id/actions"

querystring = {"actionType":""}

headers = {"accesstoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/:test-group-id/actions"

queryString <- list(actionType = "")

response <- VERB("GET", url, query = queryString, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:test-group-id/actions?actionType=")

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

request = Net::HTTP::Get.new(url)
request["accesstoken"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/groups/:test-group-id/actions') do |req|
  req.headers['accesstoken'] = ''
  req.params['actionType'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:test-group-id/actions";

    let querystring = [
        ("actionType", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/groups/:test-group-id/actions?actionType=' \
  --header 'accesstoken: '

http GET '{{baseUrl}}/groups/:test-group-id/actions?actionType=' \
  accesstoken:''

wget --quiet \
  --method GET \
  --header 'accesstoken: ' \
  --output-document \
  - '{{baseUrl}}/groups/:test-group-id/actions?actionType='

import Foundation

let headers = ["accesstoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:test-group-id/actions?actionType=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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 Fetching survey responses

{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id

HEADERS

accessToken

QUERY PARAMS

getDetails

test-group-id

test-survey-id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id" {:headers {:accesstoken ""}
                                                                                         :query-params {:getDetails ""}})

require "http/client"

url = "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails="
headers = HTTP::Headers{
  "accesstoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails="),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails=");
var request = new RestRequest("", Method.Get);
request.AddHeader("accesstoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accesstoken", "")

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

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

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

}

GET /baseUrl/groups/:test-group-id/actions/:test-survey-id?getDetails= HTTP/1.1
Accesstoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails=")
  .setHeader("accesstoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails="))
    .header("accesstoken", "")
    .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}}/groups/:test-group-id/actions/:test-survey-id?getDetails=")
  .get()
  .addHeader("accesstoken", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails=")
  .header("accesstoken", "")
  .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}}/groups/:test-group-id/actions/:test-survey-id?getDetails=');
xhr.setRequestHeader('accesstoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id',
  params: {getDetails: ''},
  headers: {accesstoken: ''}
};

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

const url = '{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails=';
const options = {method: 'GET', headers: {accesstoken: ''}};

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}}/groups/:test-group-id/actions/:test-survey-id?getDetails=',
  method: 'GET',
  headers: {
    accesstoken: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails=")
  .get()
  .addHeader("accesstoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:test-group-id/actions/:test-survey-id?getDetails=',
  headers: {
    accesstoken: ''
  }
};

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}}/groups/:test-group-id/actions/:test-survey-id',
  qs: {getDetails: ''},
  headers: {accesstoken: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id');

req.query({
  getDetails: ''
});

req.headers({
  accesstoken: ''
});

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}}/groups/:test-group-id/actions/:test-survey-id',
  params: {getDetails: ''},
  headers: {accesstoken: ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails=';
const options = {method: 'GET', headers: {accesstoken: ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails=" in
let headers = Header.add (Header.init ()) "accesstoken" "" in

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

 "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accesstoken: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails=', [
  'headers' => [
    'accesstoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'getDetails' => ''
]);

$request->setHeaders([
  'accesstoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'getDetails' => ''
]));

$request->setHeaders([
  'accesstoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails=' -Method GET -Headers $headers

import http.client

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

headers = { 'accesstoken': "" }

conn.request("GET", "/baseUrl/groups/:test-group-id/actions/:test-survey-id?getDetails=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id"

querystring = {"getDetails":""}

headers = {"accesstoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id"

queryString <- list(getDetails = "")

response <- VERB("GET", url, query = queryString, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails=")

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

request = Net::HTTP::Get.new(url)
request["accesstoken"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/groups/:test-group-id/actions/:test-survey-id') do |req|
  req.headers['accesstoken'] = ''
  req.params['getDetails'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id";

    let querystring = [
        ("getDetails", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails=' \
  --header 'accesstoken: '

http GET '{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails=' \
  accesstoken:''

wget --quiet \
  --method GET \
  --header 'accesstoken: ' \
  --output-document \
  - '{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails='

import Foundation

let headers = ["accesstoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:test-group-id/actions/:test-survey-id?getDetails=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

PUT Add Subscribers to a public group

{{baseUrl}}/groups/:test-public-group-id/subscribers/add

HEADERS

accessToken

Content-Type

QUERY PARAMS

test-public-group-id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:test-public-group-id/subscribers/add");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/groups/:test-public-group-id/subscribers/add" {:headers {:accesstoken ""
                                                                                                  :content-type ""}})

require "http/client"

url = "{{baseUrl}}/groups/:test-public-group-id/subscribers/add"
headers = HTTP::Headers{
  "accesstoken" => ""
  "content-type" => ""
}

response = HTTP::Client.put url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/groups/:test-public-group-id/subscribers/add"),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/:test-public-group-id/subscribers/add");
var request = new RestRequest("", Method.Put);
request.AddHeader("accesstoken", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups/:test-public-group-id/subscribers/add"

	req, _ := http.NewRequest("PUT", url, nil)

	req.Header.Add("accesstoken", "")
	req.Header.Add("content-type", "")

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

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

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

}

PUT /baseUrl/groups/:test-public-group-id/subscribers/add HTTP/1.1
Accesstoken: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/groups/:test-public-group-id/subscribers/add")
  .setHeader("accesstoken", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:test-public-group-id/subscribers/add"))
    .header("accesstoken", "")
    .header("content-type", "")
    .method("PUT", 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}}/groups/:test-public-group-id/subscribers/add")
  .put(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/groups/:test-public-group-id/subscribers/add")
  .header("accesstoken", "")
  .header("content-type", "")
  .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('PUT', '{{baseUrl}}/groups/:test-public-group-id/subscribers/add');
xhr.setRequestHeader('accesstoken', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/groups/:test-public-group-id/subscribers/add',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const url = '{{baseUrl}}/groups/:test-public-group-id/subscribers/add';
const options = {method: 'PUT', headers: {accesstoken: '', 'content-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}}/groups/:test-public-group-id/subscribers/add',
  method: 'PUT',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:test-public-group-id/subscribers/add")
  .put(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:test-public-group-id/subscribers/add',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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: 'PUT',
  url: '{{baseUrl}}/groups/:test-public-group-id/subscribers/add',
  headers: {accesstoken: '', 'content-type': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/groups/:test-public-group-id/subscribers/add');

req.headers({
  accesstoken: '',
  'content-type': ''
});

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

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

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/groups/:test-public-group-id/subscribers/add',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:test-public-group-id/subscribers/add';
const options = {method: 'PUT', headers: {accesstoken: '', 'content-type': ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:test-public-group-id/subscribers/add"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:test-public-group-id/subscribers/add" in
let headers = Header.add_list (Header.init ()) [
  ("accesstoken", "");
  ("content-type", "");
] in

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

 "{{baseUrl}}/groups/:test-public-group-id/subscribers/add",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "accesstoken: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/groups/:test-public-group-id/subscribers/add', [
  'headers' => [
    'accesstoken' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/groups/:test-public-group-id/subscribers/add');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups/:test-public-group-id/subscribers/add');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:test-public-group-id/subscribers/add' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:test-public-group-id/subscribers/add' -Method PUT -Headers $headers

import http.client

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

headers = {
    'accesstoken': "",
    'content-type': ""
}

conn.request("PUT", "/baseUrl/groups/:test-public-group-id/subscribers/add", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups/:test-public-group-id/subscribers/add"

headers = {
    "accesstoken": "",
    "content-type": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/:test-public-group-id/subscribers/add"

response <- VERB("PUT", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:test-public-group-id/subscribers/add")

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

request = Net::HTTP::Put.new(url)
request["accesstoken"] = ''
request["content-type"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/groups/:test-public-group-id/subscribers/add') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:test-public-group-id/subscribers/add";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/groups/:test-public-group-id/subscribers/add \
  --header 'accesstoken: ' \
  --header 'content-type: '

http PUT {{baseUrl}}/groups/:test-public-group-id/subscribers/add \
  accesstoken:'' \
  content-type:''

wget --quiet \
  --method PUT \
  --header 'accesstoken: ' \
  --header 'content-type: ' \
  --output-document \
  - {{baseUrl}}/groups/:test-public-group-id/subscribers/add

import Foundation

let headers = [
  "accesstoken": "",
  "content-type": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:test-public-group-id/subscribers/add")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

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

PUT Add members to a group

{{baseUrl}}/groups/:test-group-id/members

HEADERS

accessToken

Content-Type

QUERY PARAMS

test-group-id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:test-group-id/members");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/groups/:test-group-id/members" {:headers {:accesstoken ""
                                                                                   :content-type ""}})

require "http/client"

url = "{{baseUrl}}/groups/:test-group-id/members"
headers = HTTP::Headers{
  "accesstoken" => ""
  "content-type" => ""
}

response = HTTP::Client.put url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/groups/:test-group-id/members"),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/:test-group-id/members");
var request = new RestRequest("", Method.Put);
request.AddHeader("accesstoken", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups/:test-group-id/members"

	req, _ := http.NewRequest("PUT", url, nil)

	req.Header.Add("accesstoken", "")
	req.Header.Add("content-type", "")

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

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

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

}

PUT /baseUrl/groups/:test-group-id/members HTTP/1.1
Accesstoken: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/groups/:test-group-id/members")
  .setHeader("accesstoken", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:test-group-id/members"))
    .header("accesstoken", "")
    .header("content-type", "")
    .method("PUT", 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}}/groups/:test-group-id/members")
  .put(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/groups/:test-group-id/members")
  .header("accesstoken", "")
  .header("content-type", "")
  .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('PUT', '{{baseUrl}}/groups/:test-group-id/members');
xhr.setRequestHeader('accesstoken', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/groups/:test-group-id/members',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const url = '{{baseUrl}}/groups/:test-group-id/members';
const options = {method: 'PUT', headers: {accesstoken: '', 'content-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}}/groups/:test-group-id/members',
  method: 'PUT',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:test-group-id/members")
  .put(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:test-group-id/members',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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: 'PUT',
  url: '{{baseUrl}}/groups/:test-group-id/members',
  headers: {accesstoken: '', 'content-type': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/groups/:test-group-id/members');

req.headers({
  accesstoken: '',
  'content-type': ''
});

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

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

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/groups/:test-group-id/members',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:test-group-id/members';
const options = {method: 'PUT', headers: {accesstoken: '', 'content-type': ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:test-group-id/members"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:test-group-id/members" in
let headers = Header.add_list (Header.init ()) [
  ("accesstoken", "");
  ("content-type", "");
] in

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

 "{{baseUrl}}/groups/:test-group-id/members",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "accesstoken: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/groups/:test-group-id/members', [
  'headers' => [
    'accesstoken' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/groups/:test-group-id/members');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups/:test-group-id/members');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:test-group-id/members' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:test-group-id/members' -Method PUT -Headers $headers

import http.client

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

headers = {
    'accesstoken': "",
    'content-type': ""
}

conn.request("PUT", "/baseUrl/groups/:test-group-id/members", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups/:test-group-id/members"

headers = {
    "accesstoken": "",
    "content-type": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/:test-group-id/members"

response <- VERB("PUT", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:test-group-id/members")

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

request = Net::HTTP::Put.new(url)
request["accesstoken"] = ''
request["content-type"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/groups/:test-group-id/members') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:test-group-id/members";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/groups/:test-group-id/members \
  --header 'accesstoken: ' \
  --header 'content-type: '

http PUT {{baseUrl}}/groups/:test-group-id/members \
  accesstoken:'' \
  content-type:''

wget --quiet \
  --method PUT \
  --header 'accesstoken: ' \
  --header 'content-type: ' \
  --output-document \
  - {{baseUrl}}/groups/:test-group-id/members

import Foundation

let headers = [
  "accesstoken": "",
  "content-type": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:test-group-id/members")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

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 Create a group

{{baseUrl}}/groups

HEADERS

accessToken

Content-Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/groups" {:headers {:accesstoken ""
                                                             :content-type ""}})

require "http/client"

url = "{{baseUrl}}/groups"
headers = HTTP::Headers{
  "accesstoken" => ""
  "content-type" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/groups");
var request = new RestRequest("", Method.Post);
request.AddHeader("accesstoken", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups"

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

	req.Header.Add("accesstoken", "")
	req.Header.Add("content-type", "")

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

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

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

}

POST /baseUrl/groups HTTP/1.1
Accesstoken: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/groups")
  .setHeader("accesstoken", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups"))
    .header("accesstoken", "")
    .header("content-type", "")
    .method("POST", 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}}/groups")
  .post(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/groups")
  .header("accesstoken", "")
  .header("content-type", "")
  .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('POST', '{{baseUrl}}/groups');
xhr.setRequestHeader('accesstoken', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const url = '{{baseUrl}}/groups';
const options = {method: 'POST', headers: {accesstoken: '', 'content-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}}/groups',
  method: 'POST',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups")
  .post(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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: 'POST',
  url: '{{baseUrl}}/groups',
  headers: {accesstoken: '', 'content-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}}/groups');

req.headers({
  accesstoken: '',
  'content-type': ''
});

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

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

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups';
const options = {method: 'POST', headers: {accesstoken: '', 'content-type': ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups" in
let headers = Header.add_list (Header.init ()) [
  ("accesstoken", "");
  ("content-type", "");
] in

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

 "{{baseUrl}}/groups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "accesstoken: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/groups', [
  'headers' => [
    'accesstoken' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups');
$request->setRequestMethod('POST');
$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups' -Method POST -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups' -Method POST -Headers $headers

import http.client

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

headers = {
    'accesstoken': "",
    'content-type': ""
}

conn.request("POST", "/baseUrl/groups", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups"

headers = {
    "accesstoken": "",
    "content-type": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups"

response <- VERB("POST", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups")

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

request = Net::HTTP::Post.new(url)
request["accesstoken"] = ''
request["content-type"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/groups') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/groups \
  --header 'accesstoken: ' \
  --header 'content-type: '

http POST {{baseUrl}}/groups \
  accesstoken:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'accesstoken: ' \
  --header 'content-type: ' \
  --output-document \
  - {{baseUrl}}/groups

import Foundation

let headers = [
  "accesstoken": "",
  "content-type": ""
]

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

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 Create a sub group

{{baseUrl}}/groups/:test-group-id/subgroups

HEADERS

accessToken

Content-Type

QUERY PARAMS

test-group-id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:test-group-id/subgroups");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/groups/:test-group-id/subgroups" {:headers {:accesstoken ""
                                                                                      :content-type ""}})

require "http/client"

url = "{{baseUrl}}/groups/:test-group-id/subgroups"
headers = HTTP::Headers{
  "accesstoken" => ""
  "content-type" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/groups/:test-group-id/subgroups"),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/:test-group-id/subgroups");
var request = new RestRequest("", Method.Post);
request.AddHeader("accesstoken", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups/:test-group-id/subgroups"

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

	req.Header.Add("accesstoken", "")
	req.Header.Add("content-type", "")

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

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

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

}

POST /baseUrl/groups/:test-group-id/subgroups HTTP/1.1
Accesstoken: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/groups/:test-group-id/subgroups")
  .setHeader("accesstoken", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:test-group-id/subgroups"))
    .header("accesstoken", "")
    .header("content-type", "")
    .method("POST", 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}}/groups/:test-group-id/subgroups")
  .post(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/groups/:test-group-id/subgroups")
  .header("accesstoken", "")
  .header("content-type", "")
  .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('POST', '{{baseUrl}}/groups/:test-group-id/subgroups');
xhr.setRequestHeader('accesstoken', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups/:test-group-id/subgroups',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const url = '{{baseUrl}}/groups/:test-group-id/subgroups';
const options = {method: 'POST', headers: {accesstoken: '', 'content-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}}/groups/:test-group-id/subgroups',
  method: 'POST',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:test-group-id/subgroups")
  .post(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:test-group-id/subgroups',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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: 'POST',
  url: '{{baseUrl}}/groups/:test-group-id/subgroups',
  headers: {accesstoken: '', 'content-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}}/groups/:test-group-id/subgroups');

req.headers({
  accesstoken: '',
  'content-type': ''
});

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

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

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups/:test-group-id/subgroups',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:test-group-id/subgroups';
const options = {method: 'POST', headers: {accesstoken: '', 'content-type': ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:test-group-id/subgroups"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:test-group-id/subgroups" in
let headers = Header.add_list (Header.init ()) [
  ("accesstoken", "");
  ("content-type", "");
] in

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

 "{{baseUrl}}/groups/:test-group-id/subgroups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "accesstoken: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/groups/:test-group-id/subgroups', [
  'headers' => [
    'accesstoken' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/groups/:test-group-id/subgroups');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups/:test-group-id/subgroups');
$request->setRequestMethod('POST');
$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:test-group-id/subgroups' -Method POST -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:test-group-id/subgroups' -Method POST -Headers $headers

import http.client

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

headers = {
    'accesstoken': "",
    'content-type': ""
}

conn.request("POST", "/baseUrl/groups/:test-group-id/subgroups", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups/:test-group-id/subgroups"

headers = {
    "accesstoken": "",
    "content-type": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/:test-group-id/subgroups"

response <- VERB("POST", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:test-group-id/subgroups")

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

request = Net::HTTP::Post.new(url)
request["accesstoken"] = ''
request["content-type"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/groups/:test-group-id/subgroups') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:test-group-id/subgroups";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/groups/:test-group-id/subgroups \
  --header 'accesstoken: ' \
  --header 'content-type: '

http POST {{baseUrl}}/groups/:test-group-id/subgroups \
  accesstoken:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'accesstoken: ' \
  --header 'content-type: ' \
  --output-document \
  - {{baseUrl}}/groups/:test-group-id/subgroups

import Foundation

let headers = [
  "accesstoken": "",
  "content-type": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:test-group-id/subgroups")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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 Fetch direct groups

{{baseUrl}}/groups

HEADERS

accessToken

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/groups" {:headers {:accesstoken ""}})

require "http/client"

url = "{{baseUrl}}/groups"
headers = HTTP::Headers{
  "accesstoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/groups"),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups");
var request = new RestRequest("", Method.Get);
request.AddHeader("accesstoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accesstoken", "")

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

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

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

}

GET /baseUrl/groups HTTP/1.1
Accesstoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/groups")
  .setHeader("accesstoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups"))
    .header("accesstoken", "")
    .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}}/groups")
  .get()
  .addHeader("accesstoken", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/groups")
  .header("accesstoken", "")
  .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}}/groups');
xhr.setRequestHeader('accesstoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/groups',
  headers: {accesstoken: ''}
};

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

const url = '{{baseUrl}}/groups';
const options = {method: 'GET', headers: {accesstoken: ''}};

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}}/groups',
  method: 'GET',
  headers: {
    accesstoken: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups")
  .get()
  .addHeader("accesstoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups',
  headers: {
    accesstoken: ''
  }
};

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}}/groups',
  headers: {accesstoken: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/groups');

req.headers({
  accesstoken: ''
});

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}}/groups',
  headers: {accesstoken: ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups';
const options = {method: 'GET', headers: {accesstoken: ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups" in
let headers = Header.add (Header.init ()) "accesstoken" "" in

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

 "{{baseUrl}}/groups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accesstoken: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/groups', [
  'headers' => [
    'accesstoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/groups');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'accesstoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accesstoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups' -Method GET -Headers $headers

import http.client

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

headers = { 'accesstoken': "" }

conn.request("GET", "/baseUrl/groups", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups"

headers = {"accesstoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups"

response <- VERB("GET", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups")

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

request = Net::HTTP::Get.new(url)
request["accesstoken"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/groups') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/groups \
  --header 'accesstoken: '

http GET {{baseUrl}}/groups \
  accesstoken:''

wget --quiet \
  --method GET \
  --header 'accesstoken: ' \
  --output-document \
  - {{baseUrl}}/groups

import Foundation

let headers = ["accesstoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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 Fetch group details

{{baseUrl}}/groups/:test-group-id

HEADERS

applicationId

accessToken

QUERY PARAMS

test-group-id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:test-group-id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "applicationid: ");
headers = curl_slist_append(headers, "accesstoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/groups/:test-group-id" {:headers {:applicationid ""
                                                                           :accesstoken ""}})

require "http/client"

url = "{{baseUrl}}/groups/:test-group-id"
headers = HTTP::Headers{
  "applicationid" => ""
  "accesstoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/groups/:test-group-id"),
    Headers =
    {
        { "applicationid", "" },
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/:test-group-id");
var request = new RestRequest("", Method.Get);
request.AddHeader("applicationid", "");
request.AddHeader("accesstoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups/:test-group-id"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("applicationid", "")
	req.Header.Add("accesstoken", "")

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

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

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

}

GET /baseUrl/groups/:test-group-id HTTP/1.1
Applicationid: 
Accesstoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/groups/:test-group-id")
  .setHeader("applicationid", "")
  .setHeader("accesstoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:test-group-id"))
    .header("applicationid", "")
    .header("accesstoken", "")
    .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}}/groups/:test-group-id")
  .get()
  .addHeader("applicationid", "")
  .addHeader("accesstoken", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/groups/:test-group-id")
  .header("applicationid", "")
  .header("accesstoken", "")
  .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}}/groups/:test-group-id');
xhr.setRequestHeader('applicationid', '');
xhr.setRequestHeader('accesstoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/groups/:test-group-id',
  headers: {applicationid: '', accesstoken: ''}
};

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

const url = '{{baseUrl}}/groups/:test-group-id';
const options = {method: 'GET', headers: {applicationid: '', accesstoken: ''}};

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}}/groups/:test-group-id',
  method: 'GET',
  headers: {
    applicationid: '',
    accesstoken: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:test-group-id")
  .get()
  .addHeader("applicationid", "")
  .addHeader("accesstoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:test-group-id',
  headers: {
    applicationid: '',
    accesstoken: ''
  }
};

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}}/groups/:test-group-id',
  headers: {applicationid: '', accesstoken: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/groups/:test-group-id');

req.headers({
  applicationid: '',
  accesstoken: ''
});

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}}/groups/:test-group-id',
  headers: {applicationid: '', accesstoken: ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:test-group-id';
const options = {method: 'GET', headers: {applicationid: '', accesstoken: ''}};

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

#import 

NSDictionary *headers = @{ @"applicationid": @"",
                           @"accesstoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:test-group-id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:test-group-id" in
let headers = Header.add_list (Header.init ()) [
  ("applicationid", "");
  ("accesstoken", "");
] in

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

 "{{baseUrl}}/groups/:test-group-id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accesstoken: ",
    "applicationid: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/groups/:test-group-id', [
  'headers' => [
    'accesstoken' => '',
    'applicationid' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/groups/:test-group-id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'applicationid' => '',
  'accesstoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups/:test-group-id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'applicationid' => '',
  'accesstoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("applicationid", "")
$headers.Add("accesstoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:test-group-id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("applicationid", "")
$headers.Add("accesstoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:test-group-id' -Method GET -Headers $headers

import http.client

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

headers = {
    'applicationid': "",
    'accesstoken': ""
}

conn.request("GET", "/baseUrl/groups/:test-group-id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups/:test-group-id"

headers = {
    "applicationid": "",
    "accesstoken": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/:test-group-id"

response <- VERB("GET", url, add_headers('applicationid' = '', 'accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:test-group-id")

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

request = Net::HTTP::Get.new(url)
request["applicationid"] = ''
request["accesstoken"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/groups/:test-group-id') do |req|
  req.headers['applicationid'] = ''
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:test-group-id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("applicationid", "".parse().unwrap());
    headers.insert("accesstoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/groups/:test-group-id \
  --header 'accesstoken: ' \
  --header 'applicationid: '

http GET {{baseUrl}}/groups/:test-group-id \
  accesstoken:'' \
  applicationid:''

wget --quiet \
  --method GET \
  --header 'applicationid: ' \
  --header 'accesstoken: ' \
  --output-document \
  - {{baseUrl}}/groups/:test-group-id

import Foundation

let headers = [
  "applicationid": "",
  "accesstoken": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:test-group-id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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 Fetch members of a group

{{baseUrl}}/groups/:test-group-id/members

HEADERS

accessToken

QUERY PARAMS

test-group-id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:test-group-id/members");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/groups/:test-group-id/members" {:headers {:accesstoken ""}})

require "http/client"

url = "{{baseUrl}}/groups/:test-group-id/members"
headers = HTTP::Headers{
  "accesstoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/groups/:test-group-id/members"),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/:test-group-id/members");
var request = new RestRequest("", Method.Get);
request.AddHeader("accesstoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups/:test-group-id/members"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accesstoken", "")

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

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

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

}

GET /baseUrl/groups/:test-group-id/members HTTP/1.1
Accesstoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/groups/:test-group-id/members")
  .setHeader("accesstoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:test-group-id/members"))
    .header("accesstoken", "")
    .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}}/groups/:test-group-id/members")
  .get()
  .addHeader("accesstoken", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/groups/:test-group-id/members")
  .header("accesstoken", "")
  .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}}/groups/:test-group-id/members');
xhr.setRequestHeader('accesstoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/groups/:test-group-id/members',
  headers: {accesstoken: ''}
};

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

const url = '{{baseUrl}}/groups/:test-group-id/members';
const options = {method: 'GET', headers: {accesstoken: ''}};

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}}/groups/:test-group-id/members',
  method: 'GET',
  headers: {
    accesstoken: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:test-group-id/members")
  .get()
  .addHeader("accesstoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:test-group-id/members',
  headers: {
    accesstoken: ''
  }
};

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}}/groups/:test-group-id/members',
  headers: {accesstoken: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/groups/:test-group-id/members');

req.headers({
  accesstoken: ''
});

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}}/groups/:test-group-id/members',
  headers: {accesstoken: ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:test-group-id/members';
const options = {method: 'GET', headers: {accesstoken: ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:test-group-id/members"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:test-group-id/members" in
let headers = Header.add (Header.init ()) "accesstoken" "" in

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

 "{{baseUrl}}/groups/:test-group-id/members",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accesstoken: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/groups/:test-group-id/members', [
  'headers' => [
    'accesstoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/groups/:test-group-id/members');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'accesstoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups/:test-group-id/members');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accesstoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:test-group-id/members' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:test-group-id/members' -Method GET -Headers $headers

import http.client

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

headers = { 'accesstoken': "" }

conn.request("GET", "/baseUrl/groups/:test-group-id/members", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups/:test-group-id/members"

headers = {"accesstoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/:test-group-id/members"

response <- VERB("GET", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:test-group-id/members")

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

request = Net::HTTP::Get.new(url)
request["accesstoken"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/groups/:test-group-id/members') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:test-group-id/members";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/groups/:test-group-id/members \
  --header 'accesstoken: '

http GET {{baseUrl}}/groups/:test-group-id/members \
  accesstoken:''

wget --quiet \
  --method GET \
  --header 'accesstoken: ' \
  --output-document \
  - {{baseUrl}}/groups/:test-group-id/members

import Foundation

let headers = ["accesstoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:test-group-id/members")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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 Get Subscribers of a public group

{{baseUrl}}/groups/:test-public-group-id/subscribers

HEADERS

accessToken

Content-Type

QUERY PARAMS

test-public-group-id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:test-public-group-id/subscribers");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/groups/:test-public-group-id/subscribers" {:headers {:accesstoken ""
                                                                                               :content-type ""}})

require "http/client"

url = "{{baseUrl}}/groups/:test-public-group-id/subscribers"
headers = HTTP::Headers{
  "accesstoken" => ""
  "content-type" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/groups/:test-public-group-id/subscribers"),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/:test-public-group-id/subscribers");
var request = new RestRequest("", Method.Post);
request.AddHeader("accesstoken", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups/:test-public-group-id/subscribers"

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

	req.Header.Add("accesstoken", "")
	req.Header.Add("content-type", "")

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

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

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

}

POST /baseUrl/groups/:test-public-group-id/subscribers HTTP/1.1
Accesstoken: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/groups/:test-public-group-id/subscribers")
  .setHeader("accesstoken", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:test-public-group-id/subscribers"))
    .header("accesstoken", "")
    .header("content-type", "")
    .method("POST", 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}}/groups/:test-public-group-id/subscribers")
  .post(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/groups/:test-public-group-id/subscribers")
  .header("accesstoken", "")
  .header("content-type", "")
  .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('POST', '{{baseUrl}}/groups/:test-public-group-id/subscribers');
xhr.setRequestHeader('accesstoken', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups/:test-public-group-id/subscribers',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const url = '{{baseUrl}}/groups/:test-public-group-id/subscribers';
const options = {method: 'POST', headers: {accesstoken: '', 'content-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}}/groups/:test-public-group-id/subscribers',
  method: 'POST',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:test-public-group-id/subscribers")
  .post(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:test-public-group-id/subscribers',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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: 'POST',
  url: '{{baseUrl}}/groups/:test-public-group-id/subscribers',
  headers: {accesstoken: '', 'content-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}}/groups/:test-public-group-id/subscribers');

req.headers({
  accesstoken: '',
  'content-type': ''
});

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

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

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/groups/:test-public-group-id/subscribers',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:test-public-group-id/subscribers';
const options = {method: 'POST', headers: {accesstoken: '', 'content-type': ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:test-public-group-id/subscribers"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:test-public-group-id/subscribers" in
let headers = Header.add_list (Header.init ()) [
  ("accesstoken", "");
  ("content-type", "");
] in

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

 "{{baseUrl}}/groups/:test-public-group-id/subscribers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "accesstoken: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/groups/:test-public-group-id/subscribers', [
  'headers' => [
    'accesstoken' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/groups/:test-public-group-id/subscribers');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups/:test-public-group-id/subscribers');
$request->setRequestMethod('POST');
$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:test-public-group-id/subscribers' -Method POST -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:test-public-group-id/subscribers' -Method POST -Headers $headers

import http.client

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

headers = {
    'accesstoken': "",
    'content-type': ""
}

conn.request("POST", "/baseUrl/groups/:test-public-group-id/subscribers", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups/:test-public-group-id/subscribers"

headers = {
    "accesstoken": "",
    "content-type": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/:test-public-group-id/subscribers"

response <- VERB("POST", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:test-public-group-id/subscribers")

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

request = Net::HTTP::Post.new(url)
request["accesstoken"] = ''
request["content-type"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/groups/:test-public-group-id/subscribers') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:test-public-group-id/subscribers";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/groups/:test-public-group-id/subscribers \
  --header 'accesstoken: ' \
  --header 'content-type: '

http POST {{baseUrl}}/groups/:test-public-group-id/subscribers \
  accesstoken:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'accesstoken: ' \
  --header 'content-type: ' \
  --output-document \
  - {{baseUrl}}/groups/:test-public-group-id/subscribers

import Foundation

let headers = [
  "accesstoken": "",
  "content-type": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:test-public-group-id/subscribers")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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

PUT Remove Subscribers from a public group

{{baseUrl}}/groups/:test-public-group-id/subscribers/remove

HEADERS

accessToken

Content-Type

QUERY PARAMS

test-public-group-id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:test-public-group-id/subscribers/remove");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/groups/:test-public-group-id/subscribers/remove" {:headers {:accesstoken ""
                                                                                                     :content-type ""}})

require "http/client"

url = "{{baseUrl}}/groups/:test-public-group-id/subscribers/remove"
headers = HTTP::Headers{
  "accesstoken" => ""
  "content-type" => ""
}

response = HTTP::Client.put url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/groups/:test-public-group-id/subscribers/remove"),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/:test-public-group-id/subscribers/remove");
var request = new RestRequest("", Method.Put);
request.AddHeader("accesstoken", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups/:test-public-group-id/subscribers/remove"

	req, _ := http.NewRequest("PUT", url, nil)

	req.Header.Add("accesstoken", "")
	req.Header.Add("content-type", "")

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

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

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

}

PUT /baseUrl/groups/:test-public-group-id/subscribers/remove HTTP/1.1
Accesstoken: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/groups/:test-public-group-id/subscribers/remove")
  .setHeader("accesstoken", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:test-public-group-id/subscribers/remove"))
    .header("accesstoken", "")
    .header("content-type", "")
    .method("PUT", 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}}/groups/:test-public-group-id/subscribers/remove")
  .put(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/groups/:test-public-group-id/subscribers/remove")
  .header("accesstoken", "")
  .header("content-type", "")
  .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('PUT', '{{baseUrl}}/groups/:test-public-group-id/subscribers/remove');
xhr.setRequestHeader('accesstoken', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/groups/:test-public-group-id/subscribers/remove',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const url = '{{baseUrl}}/groups/:test-public-group-id/subscribers/remove';
const options = {method: 'PUT', headers: {accesstoken: '', 'content-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}}/groups/:test-public-group-id/subscribers/remove',
  method: 'PUT',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:test-public-group-id/subscribers/remove")
  .put(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:test-public-group-id/subscribers/remove',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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: 'PUT',
  url: '{{baseUrl}}/groups/:test-public-group-id/subscribers/remove',
  headers: {accesstoken: '', 'content-type': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/groups/:test-public-group-id/subscribers/remove');

req.headers({
  accesstoken: '',
  'content-type': ''
});

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

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

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/groups/:test-public-group-id/subscribers/remove',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:test-public-group-id/subscribers/remove';
const options = {method: 'PUT', headers: {accesstoken: '', 'content-type': ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:test-public-group-id/subscribers/remove"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:test-public-group-id/subscribers/remove" in
let headers = Header.add_list (Header.init ()) [
  ("accesstoken", "");
  ("content-type", "");
] in

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

 "{{baseUrl}}/groups/:test-public-group-id/subscribers/remove",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "accesstoken: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/groups/:test-public-group-id/subscribers/remove', [
  'headers' => [
    'accesstoken' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/groups/:test-public-group-id/subscribers/remove');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups/:test-public-group-id/subscribers/remove');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:test-public-group-id/subscribers/remove' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:test-public-group-id/subscribers/remove' -Method PUT -Headers $headers

import http.client

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

headers = {
    'accesstoken': "",
    'content-type': ""
}

conn.request("PUT", "/baseUrl/groups/:test-public-group-id/subscribers/remove", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups/:test-public-group-id/subscribers/remove"

headers = {
    "accesstoken": "",
    "content-type": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/:test-public-group-id/subscribers/remove"

response <- VERB("PUT", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:test-public-group-id/subscribers/remove")

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

request = Net::HTTP::Put.new(url)
request["accesstoken"] = ''
request["content-type"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/groups/:test-public-group-id/subscribers/remove') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:test-public-group-id/subscribers/remove";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/groups/:test-public-group-id/subscribers/remove \
  --header 'accesstoken: ' \
  --header 'content-type: '

http PUT {{baseUrl}}/groups/:test-public-group-id/subscribers/remove \
  accesstoken:'' \
  content-type:''

wget --quiet \
  --method PUT \
  --header 'accesstoken: ' \
  --header 'content-type: ' \
  --output-document \
  - {{baseUrl}}/groups/:test-public-group-id/subscribers/remove

import Foundation

let headers = [
  "accesstoken": "",
  "content-type": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:test-public-group-id/subscribers/remove")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

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 Remove group as a sub-group to another group

{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id

HEADERS

accessToken

QUERY PARAMS

test-group-id

test-sub-group-id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id" {:headers {:accesstoken ""}})

require "http/client"

url = "{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id"
headers = HTTP::Headers{
  "accesstoken" => ""
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id"),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("accesstoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("accesstoken", "")

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

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

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

}

DELETE /baseUrl/groups/:test-group-id/subGroups/:test-sub-group-id HTTP/1.1
Accesstoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id")
  .setHeader("accesstoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id"))
    .header("accesstoken", "")
    .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}}/groups/:test-group-id/subGroups/:test-sub-group-id")
  .delete(null)
  .addHeader("accesstoken", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id")
  .header("accesstoken", "")
  .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}}/groups/:test-group-id/subGroups/:test-sub-group-id');
xhr.setRequestHeader('accesstoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id',
  headers: {accesstoken: ''}
};

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

const url = '{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id';
const options = {method: 'DELETE', headers: {accesstoken: ''}};

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}}/groups/:test-group-id/subGroups/:test-sub-group-id',
  method: 'DELETE',
  headers: {
    accesstoken: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id")
  .delete(null)
  .addHeader("accesstoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:test-group-id/subGroups/:test-sub-group-id',
  headers: {
    accesstoken: ''
  }
};

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}}/groups/:test-group-id/subGroups/:test-sub-group-id',
  headers: {accesstoken: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id');

req.headers({
  accesstoken: ''
});

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}}/groups/:test-group-id/subGroups/:test-sub-group-id',
  headers: {accesstoken: ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id';
const options = {method: 'DELETE', headers: {accesstoken: ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id" in
let headers = Header.add (Header.init ()) "accesstoken" "" in

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

 "{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "accesstoken: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id', [
  'headers' => [
    'accesstoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'accesstoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'accesstoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id' -Method DELETE -Headers $headers

import http.client

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

headers = { 'accesstoken': "" }

conn.request("DELETE", "/baseUrl/groups/:test-group-id/subGroups/:test-sub-group-id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id"

headers = {"accesstoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id"

response <- VERB("DELETE", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id")

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

request = Net::HTTP::Delete.new(url)
request["accesstoken"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/groups/:test-group-id/subGroups/:test-sub-group-id') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id \
  --header 'accesstoken: '

http DELETE {{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id \
  accesstoken:''

wget --quiet \
  --method DELETE \
  --header 'accesstoken: ' \
  --output-document \
  - {{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id

import Foundation

let headers = ["accesstoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:test-group-id/subGroups/:test-sub-group-id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

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 Remove members from a group

{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e

HEADERS

accessToken

QUERY PARAMS

test-group-id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e" {:headers {:accesstoken ""}})

require "http/client"

url = "{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e"
headers = HTTP::Headers{
  "accesstoken" => ""
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e"),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e");
var request = new RestRequest("", Method.Delete);
request.AddHeader("accesstoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("accesstoken", "")

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

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

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

}

DELETE /baseUrl/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e HTTP/1.1
Accesstoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e")
  .setHeader("accesstoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e"))
    .header("accesstoken", "")
    .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}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e")
  .delete(null)
  .addHeader("accesstoken", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e")
  .header("accesstoken", "")
  .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}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e');
xhr.setRequestHeader('accesstoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e',
  headers: {accesstoken: ''}
};

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

const url = '{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e';
const options = {method: 'DELETE', headers: {accesstoken: ''}};

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}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e',
  method: 'DELETE',
  headers: {
    accesstoken: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e")
  .delete(null)
  .addHeader("accesstoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e',
  headers: {
    accesstoken: ''
  }
};

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}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e',
  headers: {accesstoken: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e');

req.headers({
  accesstoken: ''
});

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}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e',
  headers: {accesstoken: ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e';
const options = {method: 'DELETE', headers: {accesstoken: ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e" in
let headers = Header.add (Header.init ()) "accesstoken" "" in

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

 "{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "accesstoken: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e', [
  'headers' => [
    'accesstoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'accesstoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'accesstoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e' -Method DELETE -Headers $headers

import http.client

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

headers = { 'accesstoken': "" }

conn.request("DELETE", "/baseUrl/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e"

headers = {"accesstoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e"

response <- VERB("DELETE", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e")

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

request = Net::HTTP::Delete.new(url)
request["accesstoken"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e \
  --header 'accesstoken: '

http DELETE {{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e \
  accesstoken:''

wget --quiet \
  --method DELETE \
  --header 'accesstoken: ' \
  --output-document \
  - {{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e

import Foundation

let headers = ["accesstoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:test-group-id/members/364388bc-5b7f-4857-a58c-31eba18e962e")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

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

PUT This API allows lets addition of group as a sub-group to another group

{{baseUrl}}/groups/:test-group-id/subGroups

HEADERS

accessToken

Content-Type

QUERY PARAMS

test-group-id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:test-group-id/subGroups");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/groups/:test-group-id/subGroups" {:headers {:accesstoken ""
                                                                                     :content-type ""}})

require "http/client"

url = "{{baseUrl}}/groups/:test-group-id/subGroups"
headers = HTTP::Headers{
  "accesstoken" => ""
  "content-type" => ""
}

response = HTTP::Client.put url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/groups/:test-group-id/subGroups"),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/:test-group-id/subGroups");
var request = new RestRequest("", Method.Put);
request.AddHeader("accesstoken", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups/:test-group-id/subGroups"

	req, _ := http.NewRequest("PUT", url, nil)

	req.Header.Add("accesstoken", "")
	req.Header.Add("content-type", "")

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

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

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

}

PUT /baseUrl/groups/:test-group-id/subGroups HTTP/1.1
Accesstoken: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/groups/:test-group-id/subGroups")
  .setHeader("accesstoken", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:test-group-id/subGroups"))
    .header("accesstoken", "")
    .header("content-type", "")
    .method("PUT", 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}}/groups/:test-group-id/subGroups")
  .put(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/groups/:test-group-id/subGroups")
  .header("accesstoken", "")
  .header("content-type", "")
  .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('PUT', '{{baseUrl}}/groups/:test-group-id/subGroups');
xhr.setRequestHeader('accesstoken', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/groups/:test-group-id/subGroups',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const url = '{{baseUrl}}/groups/:test-group-id/subGroups';
const options = {method: 'PUT', headers: {accesstoken: '', 'content-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}}/groups/:test-group-id/subGroups',
  method: 'PUT',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:test-group-id/subGroups")
  .put(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:test-group-id/subGroups',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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: 'PUT',
  url: '{{baseUrl}}/groups/:test-group-id/subGroups',
  headers: {accesstoken: '', 'content-type': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/groups/:test-group-id/subGroups');

req.headers({
  accesstoken: '',
  'content-type': ''
});

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

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

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/groups/:test-group-id/subGroups',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:test-group-id/subGroups';
const options = {method: 'PUT', headers: {accesstoken: '', 'content-type': ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:test-group-id/subGroups"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:test-group-id/subGroups" in
let headers = Header.add_list (Header.init ()) [
  ("accesstoken", "");
  ("content-type", "");
] in

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

 "{{baseUrl}}/groups/:test-group-id/subGroups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "accesstoken: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/groups/:test-group-id/subGroups', [
  'headers' => [
    'accesstoken' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/groups/:test-group-id/subGroups');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups/:test-group-id/subGroups');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:test-group-id/subGroups' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:test-group-id/subGroups' -Method PUT -Headers $headers

import http.client

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

headers = {
    'accesstoken': "",
    'content-type': ""
}

conn.request("PUT", "/baseUrl/groups/:test-group-id/subGroups", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups/:test-group-id/subGroups"

headers = {
    "accesstoken": "",
    "content-type": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/:test-group-id/subGroups"

response <- VERB("PUT", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:test-group-id/subGroups")

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

request = Net::HTTP::Put.new(url)
request["accesstoken"] = ''
request["content-type"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/groups/:test-group-id/subGroups') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:test-group-id/subGroups";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/groups/:test-group-id/subGroups \
  --header 'accesstoken: ' \
  --header 'content-type: '

http PUT {{baseUrl}}/groups/:test-group-id/subGroups \
  accesstoken:'' \
  content-type:''

wget --quiet \
  --method PUT \
  --header 'accesstoken: ' \
  --header 'content-type: ' \
  --output-document \
  - {{baseUrl}}/groups/:test-group-id/subGroups

import Foundation

let headers = [
  "accesstoken": "",
  "content-type": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:test-group-id/subGroups")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

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 This API is used to fetch sub-groups of a group

{{baseUrl}}/groups/:test-group-id/subGroups

HEADERS

accessToken

QUERY PARAMS

test-group-id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:test-group-id/subGroups");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/groups/:test-group-id/subGroups" {:headers {:accesstoken ""}})

require "http/client"

url = "{{baseUrl}}/groups/:test-group-id/subGroups"
headers = HTTP::Headers{
  "accesstoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/groups/:test-group-id/subGroups"),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/:test-group-id/subGroups");
var request = new RestRequest("", Method.Get);
request.AddHeader("accesstoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/groups/:test-group-id/subGroups"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accesstoken", "")

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

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

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

}

GET /baseUrl/groups/:test-group-id/subGroups HTTP/1.1
Accesstoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/groups/:test-group-id/subGroups")
  .setHeader("accesstoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:test-group-id/subGroups"))
    .header("accesstoken", "")
    .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}}/groups/:test-group-id/subGroups")
  .get()
  .addHeader("accesstoken", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/groups/:test-group-id/subGroups")
  .header("accesstoken", "")
  .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}}/groups/:test-group-id/subGroups');
xhr.setRequestHeader('accesstoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/groups/:test-group-id/subGroups',
  headers: {accesstoken: ''}
};

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

const url = '{{baseUrl}}/groups/:test-group-id/subGroups';
const options = {method: 'GET', headers: {accesstoken: ''}};

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}}/groups/:test-group-id/subGroups',
  method: 'GET',
  headers: {
    accesstoken: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:test-group-id/subGroups")
  .get()
  .addHeader("accesstoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:test-group-id/subGroups',
  headers: {
    accesstoken: ''
  }
};

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}}/groups/:test-group-id/subGroups',
  headers: {accesstoken: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/groups/:test-group-id/subGroups');

req.headers({
  accesstoken: ''
});

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}}/groups/:test-group-id/subGroups',
  headers: {accesstoken: ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:test-group-id/subGroups';
const options = {method: 'GET', headers: {accesstoken: ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:test-group-id/subGroups"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:test-group-id/subGroups" in
let headers = Header.add (Header.init ()) "accesstoken" "" in

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

 "{{baseUrl}}/groups/:test-group-id/subGroups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accesstoken: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/groups/:test-group-id/subGroups', [
  'headers' => [
    'accesstoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/groups/:test-group-id/subGroups');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'accesstoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/groups/:test-group-id/subGroups');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accesstoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:test-group-id/subGroups' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:test-group-id/subGroups' -Method GET -Headers $headers

import http.client

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

headers = { 'accesstoken': "" }

conn.request("GET", "/baseUrl/groups/:test-group-id/subGroups", headers=headers)

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

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

import requests

url = "{{baseUrl}}/groups/:test-group-id/subGroups"

headers = {"accesstoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/:test-group-id/subGroups"

response <- VERB("GET", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:test-group-id/subGroups")

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

request = Net::HTTP::Get.new(url)
request["accesstoken"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/groups/:test-group-id/subGroups') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:test-group-id/subGroups";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/groups/:test-group-id/subGroups \
  --header 'accesstoken: '

http GET {{baseUrl}}/groups/:test-group-id/subGroups \
  accesstoken:''

wget --quiet \
  --method GET \
  --header 'accesstoken: ' \
  --output-document \
  - {{baseUrl}}/groups/:test-group-id/subGroups

import Foundation

let headers = ["accesstoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:test-group-id/subGroups")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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 Get all webhooks on a group

{{baseUrl}}/webhook

HEADERS

accessToken

QUERY PARAMS

objectId

objectType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/webhook?objectId=&objectType=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/webhook" {:headers {:accesstoken ""}
                                                   :query-params {:objectId ""
                                                                  :objectType ""}})

require "http/client"

url = "{{baseUrl}}/webhook?objectId=&objectType="
headers = HTTP::Headers{
  "accesstoken" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/webhook?objectId=&objectType="),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/webhook?objectId=&objectType=");
var request = new RestRequest("", Method.Get);
request.AddHeader("accesstoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/webhook?objectId=&objectType="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accesstoken", "")

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

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

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

}

GET /baseUrl/webhook?objectId=&objectType= HTTP/1.1
Accesstoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/webhook?objectId=&objectType=")
  .setHeader("accesstoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/webhook?objectId=&objectType="))
    .header("accesstoken", "")
    .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}}/webhook?objectId=&objectType=")
  .get()
  .addHeader("accesstoken", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/webhook?objectId=&objectType=")
  .header("accesstoken", "")
  .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}}/webhook?objectId=&objectType=');
xhr.setRequestHeader('accesstoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/webhook',
  params: {objectId: '', objectType: ''},
  headers: {accesstoken: ''}
};

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

const url = '{{baseUrl}}/webhook?objectId=&objectType=';
const options = {method: 'GET', headers: {accesstoken: ''}};

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}}/webhook?objectId=&objectType=',
  method: 'GET',
  headers: {
    accesstoken: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/webhook?objectId=&objectType=")
  .get()
  .addHeader("accesstoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/webhook?objectId=&objectType=',
  headers: {
    accesstoken: ''
  }
};

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}}/webhook',
  qs: {objectId: '', objectType: ''},
  headers: {accesstoken: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/webhook');

req.query({
  objectId: '',
  objectType: ''
});

req.headers({
  accesstoken: ''
});

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}}/webhook',
  params: {objectId: '', objectType: ''},
  headers: {accesstoken: ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/webhook?objectId=&objectType=';
const options = {method: 'GET', headers: {accesstoken: ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/webhook?objectId=&objectType="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/webhook?objectId=&objectType=" in
let headers = Header.add (Header.init ()) "accesstoken" "" in

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

 "{{baseUrl}}/webhook?objectId=&objectType=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accesstoken: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/webhook?objectId=&objectType=', [
  'headers' => [
    'accesstoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/webhook');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'objectId' => '',
  'objectType' => ''
]);

$request->setHeaders([
  'accesstoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/webhook');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'objectId' => '',
  'objectType' => ''
]));

$request->setHeaders([
  'accesstoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/webhook?objectId=&objectType=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/webhook?objectId=&objectType=' -Method GET -Headers $headers

import http.client

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

headers = { 'accesstoken': "" }

conn.request("GET", "/baseUrl/webhook?objectId=&objectType=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/webhook"

querystring = {"objectId":"","objectType":""}

headers = {"accesstoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/webhook"

queryString <- list(
  objectId = "",
  objectType = ""
)

response <- VERB("GET", url, query = queryString, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/webhook?objectId=&objectType=")

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

request = Net::HTTP::Get.new(url)
request["accesstoken"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/webhook') do |req|
  req.headers['accesstoken'] = ''
  req.params['objectId'] = ''
  req.params['objectType'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("objectId", ""),
        ("objectType", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/webhook?objectId=&objectType=' \
  --header 'accesstoken: '

http GET '{{baseUrl}}/webhook?objectId=&objectType=' \
  accesstoken:''

wget --quiet \
  --method GET \
  --header 'accesstoken: ' \
  --output-document \
  - '{{baseUrl}}/webhook?objectId=&objectType='

import Foundation

let headers = ["accesstoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/webhook?objectId=&objectType=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/webhook" {:headers {:accesstoken ""
                                                              :content-type ""}})

require "http/client"

url = "{{baseUrl}}/webhook"
headers = HTTP::Headers{
  "accesstoken" => ""
  "content-type" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/webhook");
var request = new RestRequest("", Method.Post);
request.AddHeader("accesstoken", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/webhook"

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

	req.Header.Add("accesstoken", "")
	req.Header.Add("content-type", "")

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

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

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

}

POST /baseUrl/webhook HTTP/1.1
Accesstoken: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/webhook")
  .setHeader("accesstoken", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/webhook"))
    .header("accesstoken", "")
    .header("content-type", "")
    .method("POST", 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}}/webhook")
  .post(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/webhook")
  .header("accesstoken", "")
  .header("content-type", "")
  .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('POST', '{{baseUrl}}/webhook');
xhr.setRequestHeader('accesstoken', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/webhook',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const url = '{{baseUrl}}/webhook';
const options = {method: 'POST', headers: {accesstoken: '', 'content-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}}/webhook',
  method: 'POST',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/webhook")
  .post(null)
  .addHeader("accesstoken", "")
  .addHeader("content-type", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/webhook',
  headers: {
    accesstoken: '',
    'content-type': ''
  }
};

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: 'POST',
  url: '{{baseUrl}}/webhook',
  headers: {accesstoken: '', 'content-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}}/webhook');

req.headers({
  accesstoken: '',
  'content-type': ''
});

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

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

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/webhook',
  headers: {accesstoken: '', 'content-type': ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/webhook';
const options = {method: 'POST', headers: {accesstoken: '', 'content-type': ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/webhook"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/webhook" in
let headers = Header.add_list (Header.init ()) [
  ("accesstoken", "");
  ("content-type", "");
] in

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

 "{{baseUrl}}/webhook",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "accesstoken: ",
    "content-type: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/webhook', [
  'headers' => [
    'accesstoken' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/webhook');
$request->setRequestMethod('POST');
$request->setHeaders([
  'accesstoken' => '',
  'content-type' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/webhook' -Method POST -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/webhook' -Method POST -Headers $headers

import http.client

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

headers = {
    'accesstoken': "",
    'content-type': ""
}

conn.request("POST", "/baseUrl/webhook", headers=headers)

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

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

import requests

url = "{{baseUrl}}/webhook"

headers = {
    "accesstoken": "",
    "content-type": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/webhook"

response <- VERB("POST", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/webhook")

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

request = Net::HTTP::Post.new(url)
request["accesstoken"] = ''
request["content-type"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/webhook') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/webhook \
  --header 'accesstoken: ' \
  --header 'content-type: '

http POST {{baseUrl}}/webhook \
  accesstoken:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'accesstoken: ' \
  --header 'content-type: ' \
  --output-document \
  - {{baseUrl}}/webhook

import Foundation

let headers = [
  "accesstoken": "",
  "content-type": ""
]

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

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 Unsubscribing awebhook

{{baseUrl}}/webhook/:test-webhook-id

HEADERS

accessToken

QUERY PARAMS

test-webhook-id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/webhook/:test-webhook-id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accesstoken: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/webhook/:test-webhook-id" {:headers {:accesstoken ""}})

require "http/client"

url = "{{baseUrl}}/webhook/:test-webhook-id"
headers = HTTP::Headers{
  "accesstoken" => ""
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/webhook/:test-webhook-id"),
    Headers =
    {
        { "accesstoken", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/webhook/:test-webhook-id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("accesstoken", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/webhook/:test-webhook-id"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("accesstoken", "")

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

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

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

}

DELETE /baseUrl/webhook/:test-webhook-id HTTP/1.1
Accesstoken: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/webhook/:test-webhook-id")
  .setHeader("accesstoken", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/webhook/:test-webhook-id"))
    .header("accesstoken", "")
    .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}}/webhook/:test-webhook-id")
  .delete(null)
  .addHeader("accesstoken", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/webhook/:test-webhook-id")
  .header("accesstoken", "")
  .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}}/webhook/:test-webhook-id');
xhr.setRequestHeader('accesstoken', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/webhook/:test-webhook-id',
  headers: {accesstoken: ''}
};

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

const url = '{{baseUrl}}/webhook/:test-webhook-id';
const options = {method: 'DELETE', headers: {accesstoken: ''}};

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}}/webhook/:test-webhook-id',
  method: 'DELETE',
  headers: {
    accesstoken: ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/webhook/:test-webhook-id")
  .delete(null)
  .addHeader("accesstoken", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/webhook/:test-webhook-id',
  headers: {
    accesstoken: ''
  }
};

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}}/webhook/:test-webhook-id',
  headers: {accesstoken: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/webhook/:test-webhook-id');

req.headers({
  accesstoken: ''
});

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}}/webhook/:test-webhook-id',
  headers: {accesstoken: ''}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/webhook/:test-webhook-id';
const options = {method: 'DELETE', headers: {accesstoken: ''}};

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

#import 

NSDictionary *headers = @{ @"accesstoken": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/webhook/:test-webhook-id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/webhook/:test-webhook-id" in
let headers = Header.add (Header.init ()) "accesstoken" "" in

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

 "{{baseUrl}}/webhook/:test-webhook-id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "accesstoken: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/webhook/:test-webhook-id', [
  'headers' => [
    'accesstoken' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/webhook/:test-webhook-id');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'accesstoken' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/webhook/:test-webhook-id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'accesstoken' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("accesstoken", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/webhook/:test-webhook-id' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("accesstoken", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/webhook/:test-webhook-id' -Method DELETE -Headers $headers

import http.client

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

headers = { 'accesstoken': "" }

conn.request("DELETE", "/baseUrl/webhook/:test-webhook-id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/webhook/:test-webhook-id"

headers = {"accesstoken": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/webhook/:test-webhook-id"

response <- VERB("DELETE", url, add_headers('accesstoken' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/webhook/:test-webhook-id")

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

request = Net::HTTP::Delete.new(url)
request["accesstoken"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/webhook/:test-webhook-id') do |req|
  req.headers['accesstoken'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/webhook/:test-webhook-id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accesstoken", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/webhook/:test-webhook-id \
  --header 'accesstoken: '

http DELETE {{baseUrl}}/webhook/:test-webhook-id \
  accesstoken:''

wget --quiet \
  --method DELETE \
  --header 'accesstoken: ' \
  --output-document \
  - {{baseUrl}}/webhook/:test-webhook-id

import Foundation

let headers = ["accesstoken": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/webhook/:test-webhook-id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

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

Microsoft Kaizala