SalesLoft Platform

GET Fetch an account stage

{{baseUrl}}/v2/account_stages/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/account_stages/:id.json");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/account_stages/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/account_stages/:id.json"

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

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

var client = new RestClient("{{baseUrl}}/v2/account_stages/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/account_stages/:id.json"

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

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

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

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

}

GET /baseUrl/v2/account_stages/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/account_stages/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/account_stages/:id.json"))
    .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}}/v2/account_stages/:id.json")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/account_stages/:id.json")
  .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}}/v2/account_stages/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/account_stages/:id.json'};

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

const url = '{{baseUrl}}/v2/account_stages/:id.json';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/account_stages/:id.json',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/account_stages/:id.json")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/account_stages/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/account_stages/:id.json'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/account_stages/:id.json');

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}}/v2/account_stages/:id.json'};

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

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

const url = '{{baseUrl}}/v2/account_stages/:id.json';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/account_stages/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/account_stages/:id.json" in

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

 "{{baseUrl}}/v2/account_stages/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/account_stages/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/account_stages/:id.json');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/account_stages/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/account_stages/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/account_stages/:id.json' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/account_stages/:id.json")

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

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

import requests

url = "{{baseUrl}}/v2/account_stages/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/account_stages/:id.json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/account_stages/:id.json")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/account_stages/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/account_stages/:id.json";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/account_stages/:id.json

http GET {{baseUrl}}/v2/account_stages/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/account_stages/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/account_stages/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET List account stages

{{baseUrl}}/v2/account_stages.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/account_stages.json");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/account_stages.json")

require "http/client"

url = "{{baseUrl}}/v2/account_stages.json"

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

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

var client = new RestClient("{{baseUrl}}/v2/account_stages.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/account_stages.json"

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

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

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

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

}

GET /baseUrl/v2/account_stages.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/account_stages.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/account_stages.json"))
    .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}}/v2/account_stages.json")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/account_stages.json")
  .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}}/v2/account_stages.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/account_stages.json'};

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

const url = '{{baseUrl}}/v2/account_stages.json';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/account_stages.json',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/account_stages.json")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/account_stages.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/account_stages.json'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/account_stages.json');

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}}/v2/account_stages.json'};

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

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

const url = '{{baseUrl}}/v2/account_stages.json';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/account_stages.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/account_stages.json" in

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

 "{{baseUrl}}/v2/account_stages.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/account_stages.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/account_stages.json');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/account_stages.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/account_stages.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/account_stages.json' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/account_stages.json")

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

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

import requests

url = "{{baseUrl}}/v2/account_stages.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/account_stages.json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/account_stages.json")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/account_stages.json') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/account_stages.json

http GET {{baseUrl}}/v2/account_stages.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/account_stages.json

import Foundation

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

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

dataTask.resume()

GET Fetch an account tier

{{baseUrl}}/v2/account_tiers/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/account_tiers/:id.json");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/account_tiers/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/account_tiers/:id.json"

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

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

var client = new RestClient("{{baseUrl}}/v2/account_tiers/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/account_tiers/:id.json"

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

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

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

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

}

GET /baseUrl/v2/account_tiers/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/account_tiers/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/account_tiers/:id.json"))
    .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}}/v2/account_tiers/:id.json")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/account_tiers/:id.json")
  .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}}/v2/account_tiers/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/account_tiers/:id.json'};

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

const url = '{{baseUrl}}/v2/account_tiers/:id.json';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/account_tiers/:id.json',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/account_tiers/:id.json")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/account_tiers/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/account_tiers/:id.json'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/account_tiers/:id.json');

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}}/v2/account_tiers/:id.json'};

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

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

const url = '{{baseUrl}}/v2/account_tiers/:id.json';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/account_tiers/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/account_tiers/:id.json" in

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

 "{{baseUrl}}/v2/account_tiers/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/account_tiers/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/account_tiers/:id.json');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/account_tiers/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/account_tiers/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/account_tiers/:id.json' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/account_tiers/:id.json")

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

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

import requests

url = "{{baseUrl}}/v2/account_tiers/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/account_tiers/:id.json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/account_tiers/:id.json")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/account_tiers/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/account_tiers/:id.json";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/account_tiers/:id.json

http GET {{baseUrl}}/v2/account_tiers/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/account_tiers/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/account_tiers/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET List Account Tiers

{{baseUrl}}/v2/account_tiers.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/account_tiers.json");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/account_tiers.json")

require "http/client"

url = "{{baseUrl}}/v2/account_tiers.json"

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

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

var client = new RestClient("{{baseUrl}}/v2/account_tiers.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/account_tiers.json"

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

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

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

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

}

GET /baseUrl/v2/account_tiers.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/account_tiers.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/account_tiers.json"))
    .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}}/v2/account_tiers.json")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/account_tiers.json")
  .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}}/v2/account_tiers.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/account_tiers.json'};

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

const url = '{{baseUrl}}/v2/account_tiers.json';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/account_tiers.json',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/account_tiers.json")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/account_tiers.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/account_tiers.json'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/account_tiers.json');

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}}/v2/account_tiers.json'};

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

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

const url = '{{baseUrl}}/v2/account_tiers.json';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/account_tiers.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/account_tiers.json" in

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

 "{{baseUrl}}/v2/account_tiers.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/account_tiers.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/account_tiers.json');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/account_tiers.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/account_tiers.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/account_tiers.json' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/account_tiers.json")

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

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

import requests

url = "{{baseUrl}}/v2/account_tiers.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/account_tiers.json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/account_tiers.json")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/account_tiers.json') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/account_tiers.json

http GET {{baseUrl}}/v2/account_tiers.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/account_tiers.json

import Foundation

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

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

dataTask.resume()

POST Upsert an account

{{baseUrl}}/v2/account_upserts.json

BODY formUrlEncoded

account_tier_id

city

company_stage_id

company_type

conversational_name

country

crm_id

crm_id_type

custom_fields

description

do_not_contact

domain

founded

industry

linkedin_url

locale

name

owner_id

phone

postal_code

revenue_range

size

state

street

tags

twitter_handle

upsert_key

website

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/account_upserts.json");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&id=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&upsert_key=&website=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/account_upserts.json" {:form-params {:account_tier_id ""
                                                                                  :city ""
                                                                                  :company_stage_id ""
                                                                                  :company_type ""
                                                                                  :conversational_name ""
                                                                                  :country ""
                                                                                  :crm_id ""
                                                                                  :crm_id_type ""
                                                                                  :custom_fields ""
                                                                                  :description ""
                                                                                  :do_not_contact ""
                                                                                  :domain ""
                                                                                  :founded ""
                                                                                  :id ""
                                                                                  :industry ""
                                                                                  :linkedin_url ""
                                                                                  :locale ""
                                                                                  :name ""
                                                                                  :owner_id ""
                                                                                  :phone ""
                                                                                  :postal_code ""
                                                                                  :revenue_range ""
                                                                                  :size ""
                                                                                  :state ""
                                                                                  :street ""
                                                                                  :tags ""
                                                                                  :twitter_handle ""
                                                                                  :upsert_key ""
                                                                                  :website ""}})

require "http/client"

url = "{{baseUrl}}/v2/account_upserts.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&id=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&upsert_key=&website="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/account_upserts.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "account_tier_id", "" },
        { "city", "" },
        { "company_stage_id", "" },
        { "company_type", "" },
        { "conversational_name", "" },
        { "country", "" },
        { "crm_id", "" },
        { "crm_id_type", "" },
        { "custom_fields", "" },
        { "description", "" },
        { "do_not_contact", "" },
        { "domain", "" },
        { "founded", "" },
        { "id", "" },
        { "industry", "" },
        { "linkedin_url", "" },
        { "locale", "" },
        { "name", "" },
        { "owner_id", "" },
        { "phone", "" },
        { "postal_code", "" },
        { "revenue_range", "" },
        { "size", "" },
        { "state", "" },
        { "street", "" },
        { "tags", "" },
        { "twitter_handle", "" },
        { "upsert_key", "" },
        { "website", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/account_upserts.json");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&id=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&upsert_key=&website=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/account_upserts.json"

	payload := strings.NewReader("account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&id=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&upsert_key=&website=")

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

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

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

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

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

}

POST /baseUrl/v2/account_upserts.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 317

account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&id=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&upsert_key=&website=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/account_upserts.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&id=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&upsert_key=&website=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/account_upserts.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&id=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&upsert_key=&website="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&id=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&upsert_key=&website=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/account_upserts.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/account_upserts.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&id=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&upsert_key=&website=")
  .asString();

const data = 'account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&id=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&upsert_key=&website=';

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

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

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

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('account_tier_id', '');
encodedParams.set('city', '');
encodedParams.set('company_stage_id', '');
encodedParams.set('company_type', '');
encodedParams.set('conversational_name', '');
encodedParams.set('country', '');
encodedParams.set('crm_id', '');
encodedParams.set('crm_id_type', '');
encodedParams.set('custom_fields', '');
encodedParams.set('description', '');
encodedParams.set('do_not_contact', '');
encodedParams.set('domain', '');
encodedParams.set('founded', '');
encodedParams.set('id', '');
encodedParams.set('industry', '');
encodedParams.set('linkedin_url', '');
encodedParams.set('locale', '');
encodedParams.set('name', '');
encodedParams.set('owner_id', '');
encodedParams.set('phone', '');
encodedParams.set('postal_code', '');
encodedParams.set('revenue_range', '');
encodedParams.set('size', '');
encodedParams.set('state', '');
encodedParams.set('street', '');
encodedParams.set('tags', '');
encodedParams.set('twitter_handle', '');
encodedParams.set('upsert_key', '');
encodedParams.set('website', '');

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

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

const url = '{{baseUrl}}/v2/account_upserts.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    account_tier_id: '',
    city: '',
    company_stage_id: '',
    company_type: '',
    conversational_name: '',
    country: '',
    crm_id: '',
    crm_id_type: '',
    custom_fields: '',
    description: '',
    do_not_contact: '',
    domain: '',
    founded: '',
    id: '',
    industry: '',
    linkedin_url: '',
    locale: '',
    name: '',
    owner_id: '',
    phone: '',
    postal_code: '',
    revenue_range: '',
    size: '',
    state: '',
    street: '',
    tags: '',
    twitter_handle: '',
    upsert_key: '',
    website: ''
  })
};

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}}/v2/account_upserts.json',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    account_tier_id: '',
    city: '',
    company_stage_id: '',
    company_type: '',
    conversational_name: '',
    country: '',
    crm_id: '',
    crm_id_type: '',
    custom_fields: '',
    description: '',
    do_not_contact: '',
    domain: '',
    founded: '',
    id: '',
    industry: '',
    linkedin_url: '',
    locale: '',
    name: '',
    owner_id: '',
    phone: '',
    postal_code: '',
    revenue_range: '',
    size: '',
    state: '',
    street: '',
    tags: '',
    twitter_handle: '',
    upsert_key: '',
    website: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&id=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&upsert_key=&website=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/account_upserts.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

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

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

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({
  account_tier_id: '',
  city: '',
  company_stage_id: '',
  company_type: '',
  conversational_name: '',
  country: '',
  crm_id: '',
  crm_id_type: '',
  custom_fields: '',
  description: '',
  do_not_contact: '',
  domain: '',
  founded: '',
  id: '',
  industry: '',
  linkedin_url: '',
  locale: '',
  name: '',
  owner_id: '',
  phone: '',
  postal_code: '',
  revenue_range: '',
  size: '',
  state: '',
  street: '',
  tags: '',
  twitter_handle: '',
  upsert_key: '',
  website: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/account_upserts.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    account_tier_id: '',
    city: '',
    company_stage_id: '',
    company_type: '',
    conversational_name: '',
    country: '',
    crm_id: '',
    crm_id_type: '',
    custom_fields: '',
    description: '',
    do_not_contact: '',
    domain: '',
    founded: '',
    id: '',
    industry: '',
    linkedin_url: '',
    locale: '',
    name: '',
    owner_id: '',
    phone: '',
    postal_code: '',
    revenue_range: '',
    size: '',
    state: '',
    street: '',
    tags: '',
    twitter_handle: '',
    upsert_key: '',
    website: ''
  }
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/account_upserts.json');

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

req.form({
  account_tier_id: '',
  city: '',
  company_stage_id: '',
  company_type: '',
  conversational_name: '',
  country: '',
  crm_id: '',
  crm_id_type: '',
  custom_fields: '',
  description: '',
  do_not_contact: '',
  domain: '',
  founded: '',
  id: '',
  industry: '',
  linkedin_url: '',
  locale: '',
  name: '',
  owner_id: '',
  phone: '',
  postal_code: '',
  revenue_range: '',
  size: '',
  state: '',
  street: '',
  tags: '',
  twitter_handle: '',
  upsert_key: '',
  website: ''
});

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

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

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

const encodedParams = new URLSearchParams();
encodedParams.set('account_tier_id', '');
encodedParams.set('city', '');
encodedParams.set('company_stage_id', '');
encodedParams.set('company_type', '');
encodedParams.set('conversational_name', '');
encodedParams.set('country', '');
encodedParams.set('crm_id', '');
encodedParams.set('crm_id_type', '');
encodedParams.set('custom_fields', '');
encodedParams.set('description', '');
encodedParams.set('do_not_contact', '');
encodedParams.set('domain', '');
encodedParams.set('founded', '');
encodedParams.set('id', '');
encodedParams.set('industry', '');
encodedParams.set('linkedin_url', '');
encodedParams.set('locale', '');
encodedParams.set('name', '');
encodedParams.set('owner_id', '');
encodedParams.set('phone', '');
encodedParams.set('postal_code', '');
encodedParams.set('revenue_range', '');
encodedParams.set('size', '');
encodedParams.set('state', '');
encodedParams.set('street', '');
encodedParams.set('tags', '');
encodedParams.set('twitter_handle', '');
encodedParams.set('upsert_key', '');
encodedParams.set('website', '');

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

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

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

const encodedParams = new URLSearchParams();
encodedParams.set('account_tier_id', '');
encodedParams.set('city', '');
encodedParams.set('company_stage_id', '');
encodedParams.set('company_type', '');
encodedParams.set('conversational_name', '');
encodedParams.set('country', '');
encodedParams.set('crm_id', '');
encodedParams.set('crm_id_type', '');
encodedParams.set('custom_fields', '');
encodedParams.set('description', '');
encodedParams.set('do_not_contact', '');
encodedParams.set('domain', '');
encodedParams.set('founded', '');
encodedParams.set('id', '');
encodedParams.set('industry', '');
encodedParams.set('linkedin_url', '');
encodedParams.set('locale', '');
encodedParams.set('name', '');
encodedParams.set('owner_id', '');
encodedParams.set('phone', '');
encodedParams.set('postal_code', '');
encodedParams.set('revenue_range', '');
encodedParams.set('size', '');
encodedParams.set('state', '');
encodedParams.set('street', '');
encodedParams.set('tags', '');
encodedParams.set('twitter_handle', '');
encodedParams.set('upsert_key', '');
encodedParams.set('website', '');

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

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

#import 

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

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"account_tier_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&city=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&company_stage_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&company_type=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&conversational_name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&country=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&crm_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&crm_id_type=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&custom_fields=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&description=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&do_not_contact=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&domain=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&founded=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&industry=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&linkedin_url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&locale=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&owner_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&phone=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&postal_code=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&revenue_range=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&size=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&state=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&street=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&tags=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&twitter_handle=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&upsert_key=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&website=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/account_upserts.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/account_upserts.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&id=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&upsert_key=&website=" in

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

 "{{baseUrl}}/v2/account_upserts.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&id=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&upsert_key=&website=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/account_upserts.json', [
  'form_params' => [
    'account_tier_id' => '',
    'city' => '',
    'company_stage_id' => '',
    'company_type' => '',
    'conversational_name' => '',
    'country' => '',
    'crm_id' => '',
    'crm_id_type' => '',
    'custom_fields' => '',
    'description' => '',
    'do_not_contact' => '',
    'domain' => '',
    'founded' => '',
    'id' => '',
    'industry' => '',
    'linkedin_url' => '',
    'locale' => '',
    'name' => '',
    'owner_id' => '',
    'phone' => '',
    'postal_code' => '',
    'revenue_range' => '',
    'size' => '',
    'state' => '',
    'street' => '',
    'tags' => '',
    'twitter_handle' => '',
    'upsert_key' => '',
    'website' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/account_upserts.json');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'account_tier_id' => '',
  'city' => '',
  'company_stage_id' => '',
  'company_type' => '',
  'conversational_name' => '',
  'country' => '',
  'crm_id' => '',
  'crm_id_type' => '',
  'custom_fields' => '',
  'description' => '',
  'do_not_contact' => '',
  'domain' => '',
  'founded' => '',
  'id' => '',
  'industry' => '',
  'linkedin_url' => '',
  'locale' => '',
  'name' => '',
  'owner_id' => '',
  'phone' => '',
  'postal_code' => '',
  'revenue_range' => '',
  'size' => '',
  'state' => '',
  'street' => '',
  'tags' => '',
  'twitter_handle' => '',
  'upsert_key' => '',
  'website' => ''
]);

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

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

append(new http\QueryString([
  'account_tier_id' => '',
  'city' => '',
  'company_stage_id' => '',
  'company_type' => '',
  'conversational_name' => '',
  'country' => '',
  'crm_id' => '',
  'crm_id_type' => '',
  'custom_fields' => '',
  'description' => '',
  'do_not_contact' => '',
  'domain' => '',
  'founded' => '',
  'id' => '',
  'industry' => '',
  'linkedin_url' => '',
  'locale' => '',
  'name' => '',
  'owner_id' => '',
  'phone' => '',
  'postal_code' => '',
  'revenue_range' => '',
  'size' => '',
  'state' => '',
  'street' => '',
  'tags' => '',
  'twitter_handle' => '',
  'upsert_key' => '',
  'website' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/account_upserts.json');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/account_upserts.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&id=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&upsert_key=&website='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/account_upserts.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&id=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&upsert_key=&website='

import http.client

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

payload = "account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&id=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&upsert_key=&website="

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

conn.request("POST", "/baseUrl/v2/account_upserts.json", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/account_upserts.json"

payload = {
    "account_tier_id": "",
    "city": "",
    "company_stage_id": "",
    "company_type": "",
    "conversational_name": "",
    "country": "",
    "crm_id": "",
    "crm_id_type": "",
    "custom_fields": "",
    "description": "",
    "do_not_contact": "",
    "domain": "",
    "founded": "",
    "id": "",
    "industry": "",
    "linkedin_url": "",
    "locale": "",
    "name": "",
    "owner_id": "",
    "phone": "",
    "postal_code": "",
    "revenue_range": "",
    "size": "",
    "state": "",
    "street": "",
    "tags": "",
    "twitter_handle": "",
    "upsert_key": "",
    "website": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/account_upserts.json"

payload <- "account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&id=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&upsert_key=&website="

encode <- "form"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/account_upserts.json")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&id=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&upsert_key=&website="

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

require 'faraday'

data = {
  :account_tier_id => "",
  :city => "",
  :company_stage_id => "",
  :company_type => "",
  :conversational_name => "",
  :country => "",
  :crm_id => "",
  :crm_id_type => "",
  :custom_fields => "",
  :description => "",
  :do_not_contact => "",
  :domain => "",
  :founded => "",
  :id => "",
  :industry => "",
  :linkedin_url => "",
  :locale => "",
  :name => "",
  :owner_id => "",
  :phone => "",
  :postal_code => "",
  :revenue_range => "",
  :size => "",
  :state => "",
  :street => "",
  :tags => "",
  :twitter_handle => "",
  :upsert_key => "",
  :website => "",
}

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

response = conn.post('/baseUrl/v2/account_upserts.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "account_tier_id": "",
        "city": "",
        "company_stage_id": "",
        "company_type": "",
        "conversational_name": "",
        "country": "",
        "crm_id": "",
        "crm_id_type": "",
        "custom_fields": "",
        "description": "",
        "do_not_contact": "",
        "domain": "",
        "founded": "",
        "id": "",
        "industry": "",
        "linkedin_url": "",
        "locale": "",
        "name": "",
        "owner_id": "",
        "phone": "",
        "postal_code": "",
        "revenue_range": "",
        "size": "",
        "state": "",
        "street": "",
        "tags": "",
        "twitter_handle": "",
        "upsert_key": "",
        "website": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/account_upserts.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data account_tier_id= \
  --data city= \
  --data company_stage_id= \
  --data company_type= \
  --data conversational_name= \
  --data country= \
  --data crm_id= \
  --data crm_id_type= \
  --data custom_fields= \
  --data description= \
  --data do_not_contact= \
  --data domain= \
  --data founded= \
  --data id= \
  --data industry= \
  --data linkedin_url= \
  --data locale= \
  --data name= \
  --data owner_id= \
  --data phone= \
  --data postal_code= \
  --data revenue_range= \
  --data size= \
  --data state= \
  --data street= \
  --data tags= \
  --data twitter_handle= \
  --data upsert_key= \
  --data website=

http --form POST {{baseUrl}}/v2/account_upserts.json \
  content-type:application/x-www-form-urlencoded \
  account_tier_id='' \
  city='' \
  company_stage_id='' \
  company_type='' \
  conversational_name='' \
  country='' \
  crm_id='' \
  crm_id_type='' \
  custom_fields='' \
  description='' \
  do_not_contact='' \
  domain='' \
  founded='' \
  id='' \
  industry='' \
  linkedin_url='' \
  locale='' \
  name='' \
  owner_id='' \
  phone='' \
  postal_code='' \
  revenue_range='' \
  size='' \
  state='' \
  street='' \
  tags='' \
  twitter_handle='' \
  upsert_key='' \
  website=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&id=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&upsert_key=&website=' \
  --output-document \
  - {{baseUrl}}/v2/account_upserts.json

import Foundation

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

let postData = NSMutableData(data: "account_tier_id=".data(using: String.Encoding.utf8)!)
postData.append("&city=".data(using: String.Encoding.utf8)!)
postData.append("&company_stage_id=".data(using: String.Encoding.utf8)!)
postData.append("&company_type=".data(using: String.Encoding.utf8)!)
postData.append("&conversational_name=".data(using: String.Encoding.utf8)!)
postData.append("&country=".data(using: String.Encoding.utf8)!)
postData.append("&crm_id=".data(using: String.Encoding.utf8)!)
postData.append("&crm_id_type=".data(using: String.Encoding.utf8)!)
postData.append("&custom_fields=".data(using: String.Encoding.utf8)!)
postData.append("&description=".data(using: String.Encoding.utf8)!)
postData.append("&do_not_contact=".data(using: String.Encoding.utf8)!)
postData.append("&domain=".data(using: String.Encoding.utf8)!)
postData.append("&founded=".data(using: String.Encoding.utf8)!)
postData.append("&id=".data(using: String.Encoding.utf8)!)
postData.append("&industry=".data(using: String.Encoding.utf8)!)
postData.append("&linkedin_url=".data(using: String.Encoding.utf8)!)
postData.append("&locale=".data(using: String.Encoding.utf8)!)
postData.append("&name=".data(using: String.Encoding.utf8)!)
postData.append("&owner_id=".data(using: String.Encoding.utf8)!)
postData.append("&phone=".data(using: String.Encoding.utf8)!)
postData.append("&postal_code=".data(using: String.Encoding.utf8)!)
postData.append("&revenue_range=".data(using: String.Encoding.utf8)!)
postData.append("&size=".data(using: String.Encoding.utf8)!)
postData.append("&state=".data(using: String.Encoding.utf8)!)
postData.append("&street=".data(using: String.Encoding.utf8)!)
postData.append("&tags=".data(using: String.Encoding.utf8)!)
postData.append("&twitter_handle=".data(using: String.Encoding.utf8)!)
postData.append("&upsert_key=".data(using: String.Encoding.utf8)!)
postData.append("&website=".data(using: String.Encoding.utf8)!)

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

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

dataTask.resume()

POST Create an account

{{baseUrl}}/v2/accounts.json

BODY formUrlEncoded

account_tier_id

city

company_stage_id

company_type

conversational_name

country

crm_id

crm_id_type

custom_fields

description

do_not_contact

domain

founded

industry

linkedin_url

locale

name

owner_id

phone

postal_code

revenue_range

size

state

street

tags

twitter_handle

website

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/accounts.json");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/accounts.json" {:form-params {:account_tier_id ""
                                                                           :city ""
                                                                           :company_stage_id ""
                                                                           :company_type ""
                                                                           :conversational_name ""
                                                                           :country ""
                                                                           :crm_id ""
                                                                           :crm_id_type ""
                                                                           :custom_fields ""
                                                                           :description ""
                                                                           :do_not_contact ""
                                                                           :domain ""
                                                                           :founded ""
                                                                           :industry ""
                                                                           :linkedin_url ""
                                                                           :locale ""
                                                                           :name ""
                                                                           :owner_id ""
                                                                           :phone ""
                                                                           :postal_code ""
                                                                           :revenue_range ""
                                                                           :size ""
                                                                           :state ""
                                                                           :street ""
                                                                           :tags ""
                                                                           :twitter_handle ""
                                                                           :website ""}})

require "http/client"

url = "{{baseUrl}}/v2/accounts.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/accounts.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "account_tier_id", "" },
        { "city", "" },
        { "company_stage_id", "" },
        { "company_type", "" },
        { "conversational_name", "" },
        { "country", "" },
        { "crm_id", "" },
        { "crm_id_type", "" },
        { "custom_fields", "" },
        { "description", "" },
        { "do_not_contact", "" },
        { "domain", "" },
        { "founded", "" },
        { "industry", "" },
        { "linkedin_url", "" },
        { "locale", "" },
        { "name", "" },
        { "owner_id", "" },
        { "phone", "" },
        { "postal_code", "" },
        { "revenue_range", "" },
        { "size", "" },
        { "state", "" },
        { "street", "" },
        { "tags", "" },
        { "twitter_handle", "" },
        { "website", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/accounts.json");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/accounts.json"

	payload := strings.NewReader("account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=")

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

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

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

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

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

}

POST /baseUrl/v2/accounts.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 301

account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/accounts.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/accounts.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/accounts.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/accounts.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=")
  .asString();

const data = 'account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=';

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

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

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

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('account_tier_id', '');
encodedParams.set('city', '');
encodedParams.set('company_stage_id', '');
encodedParams.set('company_type', '');
encodedParams.set('conversational_name', '');
encodedParams.set('country', '');
encodedParams.set('crm_id', '');
encodedParams.set('crm_id_type', '');
encodedParams.set('custom_fields', '');
encodedParams.set('description', '');
encodedParams.set('do_not_contact', '');
encodedParams.set('domain', '');
encodedParams.set('founded', '');
encodedParams.set('industry', '');
encodedParams.set('linkedin_url', '');
encodedParams.set('locale', '');
encodedParams.set('name', '');
encodedParams.set('owner_id', '');
encodedParams.set('phone', '');
encodedParams.set('postal_code', '');
encodedParams.set('revenue_range', '');
encodedParams.set('size', '');
encodedParams.set('state', '');
encodedParams.set('street', '');
encodedParams.set('tags', '');
encodedParams.set('twitter_handle', '');
encodedParams.set('website', '');

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

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

const url = '{{baseUrl}}/v2/accounts.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    account_tier_id: '',
    city: '',
    company_stage_id: '',
    company_type: '',
    conversational_name: '',
    country: '',
    crm_id: '',
    crm_id_type: '',
    custom_fields: '',
    description: '',
    do_not_contact: '',
    domain: '',
    founded: '',
    industry: '',
    linkedin_url: '',
    locale: '',
    name: '',
    owner_id: '',
    phone: '',
    postal_code: '',
    revenue_range: '',
    size: '',
    state: '',
    street: '',
    tags: '',
    twitter_handle: '',
    website: ''
  })
};

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}}/v2/accounts.json',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    account_tier_id: '',
    city: '',
    company_stage_id: '',
    company_type: '',
    conversational_name: '',
    country: '',
    crm_id: '',
    crm_id_type: '',
    custom_fields: '',
    description: '',
    do_not_contact: '',
    domain: '',
    founded: '',
    industry: '',
    linkedin_url: '',
    locale: '',
    name: '',
    owner_id: '',
    phone: '',
    postal_code: '',
    revenue_range: '',
    size: '',
    state: '',
    street: '',
    tags: '',
    twitter_handle: '',
    website: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/accounts.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

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

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

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({
  account_tier_id: '',
  city: '',
  company_stage_id: '',
  company_type: '',
  conversational_name: '',
  country: '',
  crm_id: '',
  crm_id_type: '',
  custom_fields: '',
  description: '',
  do_not_contact: '',
  domain: '',
  founded: '',
  industry: '',
  linkedin_url: '',
  locale: '',
  name: '',
  owner_id: '',
  phone: '',
  postal_code: '',
  revenue_range: '',
  size: '',
  state: '',
  street: '',
  tags: '',
  twitter_handle: '',
  website: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/accounts.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    account_tier_id: '',
    city: '',
    company_stage_id: '',
    company_type: '',
    conversational_name: '',
    country: '',
    crm_id: '',
    crm_id_type: '',
    custom_fields: '',
    description: '',
    do_not_contact: '',
    domain: '',
    founded: '',
    industry: '',
    linkedin_url: '',
    locale: '',
    name: '',
    owner_id: '',
    phone: '',
    postal_code: '',
    revenue_range: '',
    size: '',
    state: '',
    street: '',
    tags: '',
    twitter_handle: '',
    website: ''
  }
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/accounts.json');

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

req.form({
  account_tier_id: '',
  city: '',
  company_stage_id: '',
  company_type: '',
  conversational_name: '',
  country: '',
  crm_id: '',
  crm_id_type: '',
  custom_fields: '',
  description: '',
  do_not_contact: '',
  domain: '',
  founded: '',
  industry: '',
  linkedin_url: '',
  locale: '',
  name: '',
  owner_id: '',
  phone: '',
  postal_code: '',
  revenue_range: '',
  size: '',
  state: '',
  street: '',
  tags: '',
  twitter_handle: '',
  website: ''
});

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

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

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

const encodedParams = new URLSearchParams();
encodedParams.set('account_tier_id', '');
encodedParams.set('city', '');
encodedParams.set('company_stage_id', '');
encodedParams.set('company_type', '');
encodedParams.set('conversational_name', '');
encodedParams.set('country', '');
encodedParams.set('crm_id', '');
encodedParams.set('crm_id_type', '');
encodedParams.set('custom_fields', '');
encodedParams.set('description', '');
encodedParams.set('do_not_contact', '');
encodedParams.set('domain', '');
encodedParams.set('founded', '');
encodedParams.set('industry', '');
encodedParams.set('linkedin_url', '');
encodedParams.set('locale', '');
encodedParams.set('name', '');
encodedParams.set('owner_id', '');
encodedParams.set('phone', '');
encodedParams.set('postal_code', '');
encodedParams.set('revenue_range', '');
encodedParams.set('size', '');
encodedParams.set('state', '');
encodedParams.set('street', '');
encodedParams.set('tags', '');
encodedParams.set('twitter_handle', '');
encodedParams.set('website', '');

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

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

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

const encodedParams = new URLSearchParams();
encodedParams.set('account_tier_id', '');
encodedParams.set('city', '');
encodedParams.set('company_stage_id', '');
encodedParams.set('company_type', '');
encodedParams.set('conversational_name', '');
encodedParams.set('country', '');
encodedParams.set('crm_id', '');
encodedParams.set('crm_id_type', '');
encodedParams.set('custom_fields', '');
encodedParams.set('description', '');
encodedParams.set('do_not_contact', '');
encodedParams.set('domain', '');
encodedParams.set('founded', '');
encodedParams.set('industry', '');
encodedParams.set('linkedin_url', '');
encodedParams.set('locale', '');
encodedParams.set('name', '');
encodedParams.set('owner_id', '');
encodedParams.set('phone', '');
encodedParams.set('postal_code', '');
encodedParams.set('revenue_range', '');
encodedParams.set('size', '');
encodedParams.set('state', '');
encodedParams.set('street', '');
encodedParams.set('tags', '');
encodedParams.set('twitter_handle', '');
encodedParams.set('website', '');

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

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

#import 

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

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"account_tier_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&city=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&company_stage_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&company_type=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&conversational_name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&country=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&crm_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&crm_id_type=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&custom_fields=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&description=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&do_not_contact=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&domain=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&founded=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&industry=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&linkedin_url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&locale=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&owner_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&phone=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&postal_code=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&revenue_range=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&size=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&state=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&street=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&tags=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&twitter_handle=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&website=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/accounts.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/accounts.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=" in

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

 "{{baseUrl}}/v2/accounts.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/accounts.json', [
  'form_params' => [
    'account_tier_id' => '',
    'city' => '',
    'company_stage_id' => '',
    'company_type' => '',
    'conversational_name' => '',
    'country' => '',
    'crm_id' => '',
    'crm_id_type' => '',
    'custom_fields' => '',
    'description' => '',
    'do_not_contact' => '',
    'domain' => '',
    'founded' => '',
    'industry' => '',
    'linkedin_url' => '',
    'locale' => '',
    'name' => '',
    'owner_id' => '',
    'phone' => '',
    'postal_code' => '',
    'revenue_range' => '',
    'size' => '',
    'state' => '',
    'street' => '',
    'tags' => '',
    'twitter_handle' => '',
    'website' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/accounts.json');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'account_tier_id' => '',
  'city' => '',
  'company_stage_id' => '',
  'company_type' => '',
  'conversational_name' => '',
  'country' => '',
  'crm_id' => '',
  'crm_id_type' => '',
  'custom_fields' => '',
  'description' => '',
  'do_not_contact' => '',
  'domain' => '',
  'founded' => '',
  'industry' => '',
  'linkedin_url' => '',
  'locale' => '',
  'name' => '',
  'owner_id' => '',
  'phone' => '',
  'postal_code' => '',
  'revenue_range' => '',
  'size' => '',
  'state' => '',
  'street' => '',
  'tags' => '',
  'twitter_handle' => '',
  'website' => ''
]);

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

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

append(new http\QueryString([
  'account_tier_id' => '',
  'city' => '',
  'company_stage_id' => '',
  'company_type' => '',
  'conversational_name' => '',
  'country' => '',
  'crm_id' => '',
  'crm_id_type' => '',
  'custom_fields' => '',
  'description' => '',
  'do_not_contact' => '',
  'domain' => '',
  'founded' => '',
  'industry' => '',
  'linkedin_url' => '',
  'locale' => '',
  'name' => '',
  'owner_id' => '',
  'phone' => '',
  'postal_code' => '',
  'revenue_range' => '',
  'size' => '',
  'state' => '',
  'street' => '',
  'tags' => '',
  'twitter_handle' => '',
  'website' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/accounts.json');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/accounts.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/accounts.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website='

import http.client

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

payload = "account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website="

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

conn.request("POST", "/baseUrl/v2/accounts.json", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/accounts.json"

payload = {
    "account_tier_id": "",
    "city": "",
    "company_stage_id": "",
    "company_type": "",
    "conversational_name": "",
    "country": "",
    "crm_id": "",
    "crm_id_type": "",
    "custom_fields": "",
    "description": "",
    "do_not_contact": "",
    "domain": "",
    "founded": "",
    "industry": "",
    "linkedin_url": "",
    "locale": "",
    "name": "",
    "owner_id": "",
    "phone": "",
    "postal_code": "",
    "revenue_range": "",
    "size": "",
    "state": "",
    "street": "",
    "tags": "",
    "twitter_handle": "",
    "website": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/accounts.json"

payload <- "account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website="

encode <- "form"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/accounts.json")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website="

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

require 'faraday'

data = {
  :account_tier_id => "",
  :city => "",
  :company_stage_id => "",
  :company_type => "",
  :conversational_name => "",
  :country => "",
  :crm_id => "",
  :crm_id_type => "",
  :custom_fields => "",
  :description => "",
  :do_not_contact => "",
  :domain => "",
  :founded => "",
  :industry => "",
  :linkedin_url => "",
  :locale => "",
  :name => "",
  :owner_id => "",
  :phone => "",
  :postal_code => "",
  :revenue_range => "",
  :size => "",
  :state => "",
  :street => "",
  :tags => "",
  :twitter_handle => "",
  :website => "",
}

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

response = conn.post('/baseUrl/v2/accounts.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "account_tier_id": "",
        "city": "",
        "company_stage_id": "",
        "company_type": "",
        "conversational_name": "",
        "country": "",
        "crm_id": "",
        "crm_id_type": "",
        "custom_fields": "",
        "description": "",
        "do_not_contact": "",
        "domain": "",
        "founded": "",
        "industry": "",
        "linkedin_url": "",
        "locale": "",
        "name": "",
        "owner_id": "",
        "phone": "",
        "postal_code": "",
        "revenue_range": "",
        "size": "",
        "state": "",
        "street": "",
        "tags": "",
        "twitter_handle": "",
        "website": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/accounts.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data account_tier_id= \
  --data city= \
  --data company_stage_id= \
  --data company_type= \
  --data conversational_name= \
  --data country= \
  --data crm_id= \
  --data crm_id_type= \
  --data custom_fields= \
  --data description= \
  --data do_not_contact= \
  --data domain= \
  --data founded= \
  --data industry= \
  --data linkedin_url= \
  --data locale= \
  --data name= \
  --data owner_id= \
  --data phone= \
  --data postal_code= \
  --data revenue_range= \
  --data size= \
  --data state= \
  --data street= \
  --data tags= \
  --data twitter_handle= \
  --data website=

http --form POST {{baseUrl}}/v2/accounts.json \
  content-type:application/x-www-form-urlencoded \
  account_tier_id='' \
  city='' \
  company_stage_id='' \
  company_type='' \
  conversational_name='' \
  country='' \
  crm_id='' \
  crm_id_type='' \
  custom_fields='' \
  description='' \
  do_not_contact='' \
  domain='' \
  founded='' \
  industry='' \
  linkedin_url='' \
  locale='' \
  name='' \
  owner_id='' \
  phone='' \
  postal_code='' \
  revenue_range='' \
  size='' \
  state='' \
  street='' \
  tags='' \
  twitter_handle='' \
  website=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'account_tier_id=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=' \
  --output-document \
  - {{baseUrl}}/v2/accounts.json

import Foundation

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

let postData = NSMutableData(data: "account_tier_id=".data(using: String.Encoding.utf8)!)
postData.append("&city=".data(using: String.Encoding.utf8)!)
postData.append("&company_stage_id=".data(using: String.Encoding.utf8)!)
postData.append("&company_type=".data(using: String.Encoding.utf8)!)
postData.append("&conversational_name=".data(using: String.Encoding.utf8)!)
postData.append("&country=".data(using: String.Encoding.utf8)!)
postData.append("&crm_id=".data(using: String.Encoding.utf8)!)
postData.append("&crm_id_type=".data(using: String.Encoding.utf8)!)
postData.append("&custom_fields=".data(using: String.Encoding.utf8)!)
postData.append("&description=".data(using: String.Encoding.utf8)!)
postData.append("&do_not_contact=".data(using: String.Encoding.utf8)!)
postData.append("&domain=".data(using: String.Encoding.utf8)!)
postData.append("&founded=".data(using: String.Encoding.utf8)!)
postData.append("&industry=".data(using: String.Encoding.utf8)!)
postData.append("&linkedin_url=".data(using: String.Encoding.utf8)!)
postData.append("&locale=".data(using: String.Encoding.utf8)!)
postData.append("&name=".data(using: String.Encoding.utf8)!)
postData.append("&owner_id=".data(using: String.Encoding.utf8)!)
postData.append("&phone=".data(using: String.Encoding.utf8)!)
postData.append("&postal_code=".data(using: String.Encoding.utf8)!)
postData.append("&revenue_range=".data(using: String.Encoding.utf8)!)
postData.append("&size=".data(using: String.Encoding.utf8)!)
postData.append("&state=".data(using: String.Encoding.utf8)!)
postData.append("&street=".data(using: String.Encoding.utf8)!)
postData.append("&tags=".data(using: String.Encoding.utf8)!)
postData.append("&twitter_handle=".data(using: String.Encoding.utf8)!)
postData.append("&website=".data(using: String.Encoding.utf8)!)

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

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

dataTask.resume()

DELETE Delete an account

{{baseUrl}}/v2/accounts/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/accounts/:id.json");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v2/accounts/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/accounts/:id.json"

response = HTTP::Client.delete url
puts response.body

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

var client = new RestClient("{{baseUrl}}/v2/accounts/:id.json");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/accounts/:id.json"

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

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

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

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

}

DELETE /baseUrl/v2/accounts/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/accounts/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/accounts/:id.json"))
    .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}}/v2/accounts/:id.json")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v2/accounts/:id.json")
  .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}}/v2/accounts/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v2/accounts/:id.json'};

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

const url = '{{baseUrl}}/v2/accounts/:id.json';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/accounts/:id.json',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/accounts/:id.json")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/accounts/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/v2/accounts/:id.json'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/accounts/:id.json');

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}}/v2/accounts/:id.json'};

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

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

const url = '{{baseUrl}}/v2/accounts/:id.json';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/accounts/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/accounts/:id.json" in

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

 "{{baseUrl}}/v2/accounts/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/v2/accounts/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/accounts/:id.json');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v2/accounts/:id.json');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/accounts/:id.json' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/accounts/:id.json' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v2/accounts/:id.json")

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

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

import requests

url = "{{baseUrl}}/v2/accounts/:id.json"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/accounts/:id.json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/accounts/:id.json")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

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

response = conn.delete('/baseUrl/v2/accounts/:id.json') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/accounts/:id.json";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v2/accounts/:id.json

http DELETE {{baseUrl}}/v2/accounts/:id.json

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/accounts/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/accounts/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

GET Fetch an account

{{baseUrl}}/v2/accounts/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/accounts/:id.json");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/accounts/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/accounts/:id.json"

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

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

var client = new RestClient("{{baseUrl}}/v2/accounts/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/accounts/:id.json"

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

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

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

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

}

GET /baseUrl/v2/accounts/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/accounts/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/accounts/:id.json"))
    .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}}/v2/accounts/:id.json")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/accounts/:id.json")
  .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}}/v2/accounts/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/accounts/:id.json'};

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

const url = '{{baseUrl}}/v2/accounts/:id.json';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/accounts/:id.json',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/accounts/:id.json")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/accounts/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/accounts/:id.json'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/accounts/:id.json');

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}}/v2/accounts/:id.json'};

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

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

const url = '{{baseUrl}}/v2/accounts/:id.json';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/accounts/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/accounts/:id.json" in

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

 "{{baseUrl}}/v2/accounts/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/accounts/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/accounts/:id.json');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/accounts/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/accounts/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/accounts/:id.json' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/accounts/:id.json")

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

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

import requests

url = "{{baseUrl}}/v2/accounts/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/accounts/:id.json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/accounts/:id.json")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/accounts/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/accounts/:id.json";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/accounts/:id.json

http GET {{baseUrl}}/v2/accounts/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/accounts/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/accounts/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET List accounts

{{baseUrl}}/v2/accounts.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/accounts.json");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/accounts.json")

require "http/client"

url = "{{baseUrl}}/v2/accounts.json"

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

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

var client = new RestClient("{{baseUrl}}/v2/accounts.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/accounts.json"

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

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

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

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

}

GET /baseUrl/v2/accounts.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/accounts.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/accounts.json"))
    .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}}/v2/accounts.json")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/accounts.json")
  .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}}/v2/accounts.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/accounts.json'};

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

const url = '{{baseUrl}}/v2/accounts.json';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/accounts.json',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/accounts.json")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/accounts.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/accounts.json'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/accounts.json');

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}}/v2/accounts.json'};

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

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

const url = '{{baseUrl}}/v2/accounts.json';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/accounts.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/accounts.json" in

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

 "{{baseUrl}}/v2/accounts.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/accounts.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/accounts.json');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/accounts.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/accounts.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/accounts.json' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/accounts.json")

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

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

import requests

url = "{{baseUrl}}/v2/accounts.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/accounts.json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/accounts.json")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/accounts.json') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/accounts.json

http GET {{baseUrl}}/v2/accounts.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/accounts.json

import Foundation

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

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

dataTask.resume()

PUT Update an existing Account

{{baseUrl}}/v2/accounts/:id.json

QUERY PARAMS

BODY formUrlEncoded

account_tier_id

archived

city

company_stage_id

company_type

conversational_name

country

crm_id

crm_id_type

custom_fields

description

do_not_contact

domain

founded

industry

linkedin_url

locale

name

owner_id

phone

postal_code

revenue_range

size

state

street

tags

twitter_handle

website

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/accounts/:id.json");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "account_tier_id=&archived=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/v2/accounts/:id.json" {:form-params {:account_tier_id ""
                                                                              :archived ""
                                                                              :city ""
                                                                              :company_stage_id ""
                                                                              :company_type ""
                                                                              :conversational_name ""
                                                                              :country ""
                                                                              :crm_id ""
                                                                              :crm_id_type ""
                                                                              :custom_fields ""
                                                                              :description ""
                                                                              :do_not_contact ""
                                                                              :domain ""
                                                                              :founded ""
                                                                              :industry ""
                                                                              :linkedin_url ""
                                                                              :locale ""
                                                                              :name ""
                                                                              :owner_id ""
                                                                              :phone ""
                                                                              :postal_code ""
                                                                              :revenue_range ""
                                                                              :size ""
                                                                              :state ""
                                                                              :street ""
                                                                              :tags ""
                                                                              :twitter_handle ""
                                                                              :website ""}})

require "http/client"

url = "{{baseUrl}}/v2/accounts/:id.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "account_tier_id=&archived=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v2/accounts/:id.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "account_tier_id", "" },
        { "archived", "" },
        { "city", "" },
        { "company_stage_id", "" },
        { "company_type", "" },
        { "conversational_name", "" },
        { "country", "" },
        { "crm_id", "" },
        { "crm_id_type", "" },
        { "custom_fields", "" },
        { "description", "" },
        { "do_not_contact", "" },
        { "domain", "" },
        { "founded", "" },
        { "industry", "" },
        { "linkedin_url", "" },
        { "locale", "" },
        { "name", "" },
        { "owner_id", "" },
        { "phone", "" },
        { "postal_code", "" },
        { "revenue_range", "" },
        { "size", "" },
        { "state", "" },
        { "street", "" },
        { "tags", "" },
        { "twitter_handle", "" },
        { "website", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/accounts/:id.json");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "account_tier_id=&archived=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/accounts/:id.json"

	payload := strings.NewReader("account_tier_id=&archived=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=")

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

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

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

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

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

}

PUT /baseUrl/v2/accounts/:id.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 311

account_tier_id=&archived=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v2/accounts/:id.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("account_tier_id=&archived=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/accounts/:id.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("PUT", HttpRequest.BodyPublishers.ofString("account_tier_id=&archived=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "account_tier_id=&archived=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/accounts/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/v2/accounts/:id.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("account_tier_id=&archived=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=")
  .asString();

const data = 'account_tier_id=&archived=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=';

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

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

xhr.open('PUT', '{{baseUrl}}/v2/accounts/:id.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('account_tier_id', '');
encodedParams.set('archived', '');
encodedParams.set('city', '');
encodedParams.set('company_stage_id', '');
encodedParams.set('company_type', '');
encodedParams.set('conversational_name', '');
encodedParams.set('country', '');
encodedParams.set('crm_id', '');
encodedParams.set('crm_id_type', '');
encodedParams.set('custom_fields', '');
encodedParams.set('description', '');
encodedParams.set('do_not_contact', '');
encodedParams.set('domain', '');
encodedParams.set('founded', '');
encodedParams.set('industry', '');
encodedParams.set('linkedin_url', '');
encodedParams.set('locale', '');
encodedParams.set('name', '');
encodedParams.set('owner_id', '');
encodedParams.set('phone', '');
encodedParams.set('postal_code', '');
encodedParams.set('revenue_range', '');
encodedParams.set('size', '');
encodedParams.set('state', '');
encodedParams.set('street', '');
encodedParams.set('tags', '');
encodedParams.set('twitter_handle', '');
encodedParams.set('website', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/accounts/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/v2/accounts/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    account_tier_id: '',
    archived: '',
    city: '',
    company_stage_id: '',
    company_type: '',
    conversational_name: '',
    country: '',
    crm_id: '',
    crm_id_type: '',
    custom_fields: '',
    description: '',
    do_not_contact: '',
    domain: '',
    founded: '',
    industry: '',
    linkedin_url: '',
    locale: '',
    name: '',
    owner_id: '',
    phone: '',
    postal_code: '',
    revenue_range: '',
    size: '',
    state: '',
    street: '',
    tags: '',
    twitter_handle: '',
    website: ''
  })
};

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}}/v2/accounts/:id.json',
  method: 'PUT',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    account_tier_id: '',
    archived: '',
    city: '',
    company_stage_id: '',
    company_type: '',
    conversational_name: '',
    country: '',
    crm_id: '',
    crm_id_type: '',
    custom_fields: '',
    description: '',
    do_not_contact: '',
    domain: '',
    founded: '',
    industry: '',
    linkedin_url: '',
    locale: '',
    name: '',
    owner_id: '',
    phone: '',
    postal_code: '',
    revenue_range: '',
    size: '',
    state: '',
    street: '',
    tags: '',
    twitter_handle: '',
    website: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "account_tier_id=&archived=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/accounts/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

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

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/accounts/:id.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({
  account_tier_id: '',
  archived: '',
  city: '',
  company_stage_id: '',
  company_type: '',
  conversational_name: '',
  country: '',
  crm_id: '',
  crm_id_type: '',
  custom_fields: '',
  description: '',
  do_not_contact: '',
  domain: '',
  founded: '',
  industry: '',
  linkedin_url: '',
  locale: '',
  name: '',
  owner_id: '',
  phone: '',
  postal_code: '',
  revenue_range: '',
  size: '',
  state: '',
  street: '',
  tags: '',
  twitter_handle: '',
  website: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/accounts/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    account_tier_id: '',
    archived: '',
    city: '',
    company_stage_id: '',
    company_type: '',
    conversational_name: '',
    country: '',
    crm_id: '',
    crm_id_type: '',
    custom_fields: '',
    description: '',
    do_not_contact: '',
    domain: '',
    founded: '',
    industry: '',
    linkedin_url: '',
    locale: '',
    name: '',
    owner_id: '',
    phone: '',
    postal_code: '',
    revenue_range: '',
    size: '',
    state: '',
    street: '',
    tags: '',
    twitter_handle: '',
    website: ''
  }
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/v2/accounts/:id.json');

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

req.form({
  account_tier_id: '',
  archived: '',
  city: '',
  company_stage_id: '',
  company_type: '',
  conversational_name: '',
  country: '',
  crm_id: '',
  crm_id_type: '',
  custom_fields: '',
  description: '',
  do_not_contact: '',
  domain: '',
  founded: '',
  industry: '',
  linkedin_url: '',
  locale: '',
  name: '',
  owner_id: '',
  phone: '',
  postal_code: '',
  revenue_range: '',
  size: '',
  state: '',
  street: '',
  tags: '',
  twitter_handle: '',
  website: ''
});

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

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

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

const encodedParams = new URLSearchParams();
encodedParams.set('account_tier_id', '');
encodedParams.set('archived', '');
encodedParams.set('city', '');
encodedParams.set('company_stage_id', '');
encodedParams.set('company_type', '');
encodedParams.set('conversational_name', '');
encodedParams.set('country', '');
encodedParams.set('crm_id', '');
encodedParams.set('crm_id_type', '');
encodedParams.set('custom_fields', '');
encodedParams.set('description', '');
encodedParams.set('do_not_contact', '');
encodedParams.set('domain', '');
encodedParams.set('founded', '');
encodedParams.set('industry', '');
encodedParams.set('linkedin_url', '');
encodedParams.set('locale', '');
encodedParams.set('name', '');
encodedParams.set('owner_id', '');
encodedParams.set('phone', '');
encodedParams.set('postal_code', '');
encodedParams.set('revenue_range', '');
encodedParams.set('size', '');
encodedParams.set('state', '');
encodedParams.set('street', '');
encodedParams.set('tags', '');
encodedParams.set('twitter_handle', '');
encodedParams.set('website', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/accounts/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

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

const encodedParams = new URLSearchParams();
encodedParams.set('account_tier_id', '');
encodedParams.set('archived', '');
encodedParams.set('city', '');
encodedParams.set('company_stage_id', '');
encodedParams.set('company_type', '');
encodedParams.set('conversational_name', '');
encodedParams.set('country', '');
encodedParams.set('crm_id', '');
encodedParams.set('crm_id_type', '');
encodedParams.set('custom_fields', '');
encodedParams.set('description', '');
encodedParams.set('do_not_contact', '');
encodedParams.set('domain', '');
encodedParams.set('founded', '');
encodedParams.set('industry', '');
encodedParams.set('linkedin_url', '');
encodedParams.set('locale', '');
encodedParams.set('name', '');
encodedParams.set('owner_id', '');
encodedParams.set('phone', '');
encodedParams.set('postal_code', '');
encodedParams.set('revenue_range', '');
encodedParams.set('size', '');
encodedParams.set('state', '');
encodedParams.set('street', '');
encodedParams.set('tags', '');
encodedParams.set('twitter_handle', '');
encodedParams.set('website', '');

const url = '{{baseUrl}}/v2/accounts/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

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

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"account_tier_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&archived=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&city=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&company_stage_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&company_type=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&conversational_name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&country=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&crm_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&crm_id_type=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&custom_fields=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&description=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&do_not_contact=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&domain=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&founded=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&industry=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&linkedin_url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&locale=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&owner_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&phone=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&postal_code=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&revenue_range=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&size=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&state=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&street=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&tags=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&twitter_handle=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&website=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/accounts/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/accounts/:id.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "account_tier_id=&archived=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=" in

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

 "{{baseUrl}}/v2/accounts/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => "account_tier_id=&archived=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/v2/accounts/:id.json', [
  'form_params' => [
    'account_tier_id' => '',
    'archived' => '',
    'city' => '',
    'company_stage_id' => '',
    'company_type' => '',
    'conversational_name' => '',
    'country' => '',
    'crm_id' => '',
    'crm_id_type' => '',
    'custom_fields' => '',
    'description' => '',
    'do_not_contact' => '',
    'domain' => '',
    'founded' => '',
    'industry' => '',
    'linkedin_url' => '',
    'locale' => '',
    'name' => '',
    'owner_id' => '',
    'phone' => '',
    'postal_code' => '',
    'revenue_range' => '',
    'size' => '',
    'state' => '',
    'street' => '',
    'tags' => '',
    'twitter_handle' => '',
    'website' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/accounts/:id.json');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'account_tier_id' => '',
  'archived' => '',
  'city' => '',
  'company_stage_id' => '',
  'company_type' => '',
  'conversational_name' => '',
  'country' => '',
  'crm_id' => '',
  'crm_id_type' => '',
  'custom_fields' => '',
  'description' => '',
  'do_not_contact' => '',
  'domain' => '',
  'founded' => '',
  'industry' => '',
  'linkedin_url' => '',
  'locale' => '',
  'name' => '',
  'owner_id' => '',
  'phone' => '',
  'postal_code' => '',
  'revenue_range' => '',
  'size' => '',
  'state' => '',
  'street' => '',
  'tags' => '',
  'twitter_handle' => '',
  'website' => ''
]);

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

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

append(new http\QueryString([
  'account_tier_id' => '',
  'archived' => '',
  'city' => '',
  'company_stage_id' => '',
  'company_type' => '',
  'conversational_name' => '',
  'country' => '',
  'crm_id' => '',
  'crm_id_type' => '',
  'custom_fields' => '',
  'description' => '',
  'do_not_contact' => '',
  'domain' => '',
  'founded' => '',
  'industry' => '',
  'linkedin_url' => '',
  'locale' => '',
  'name' => '',
  'owner_id' => '',
  'phone' => '',
  'postal_code' => '',
  'revenue_range' => '',
  'size' => '',
  'state' => '',
  'street' => '',
  'tags' => '',
  'twitter_handle' => '',
  'website' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/accounts/:id.json');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/accounts/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'account_tier_id=&archived=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/accounts/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'account_tier_id=&archived=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website='

import http.client

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

payload = "account_tier_id=&archived=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website="

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

conn.request("PUT", "/baseUrl/v2/accounts/:id.json", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/accounts/:id.json"

payload = {
    "account_tier_id": "",
    "archived": "",
    "city": "",
    "company_stage_id": "",
    "company_type": "",
    "conversational_name": "",
    "country": "",
    "crm_id": "",
    "crm_id_type": "",
    "custom_fields": "",
    "description": "",
    "do_not_contact": "",
    "domain": "",
    "founded": "",
    "industry": "",
    "linkedin_url": "",
    "locale": "",
    "name": "",
    "owner_id": "",
    "phone": "",
    "postal_code": "",
    "revenue_range": "",
    "size": "",
    "state": "",
    "street": "",
    "tags": "",
    "twitter_handle": "",
    "website": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/accounts/:id.json"

payload <- "account_tier_id=&archived=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website="

encode <- "form"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/accounts/:id.json")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "account_tier_id=&archived=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website="

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

require 'faraday'

data = {
  :account_tier_id => "",
  :archived => "",
  :city => "",
  :company_stage_id => "",
  :company_type => "",
  :conversational_name => "",
  :country => "",
  :crm_id => "",
  :crm_id_type => "",
  :custom_fields => "",
  :description => "",
  :do_not_contact => "",
  :domain => "",
  :founded => "",
  :industry => "",
  :linkedin_url => "",
  :locale => "",
  :name => "",
  :owner_id => "",
  :phone => "",
  :postal_code => "",
  :revenue_range => "",
  :size => "",
  :state => "",
  :street => "",
  :tags => "",
  :twitter_handle => "",
  :website => "",
}

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

response = conn.put('/baseUrl/v2/accounts/:id.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/accounts/:id.json";

    let payload = json!({
        "account_tier_id": "",
        "archived": "",
        "city": "",
        "company_stage_id": "",
        "company_type": "",
        "conversational_name": "",
        "country": "",
        "crm_id": "",
        "crm_id_type": "",
        "custom_fields": "",
        "description": "",
        "do_not_contact": "",
        "domain": "",
        "founded": "",
        "industry": "",
        "linkedin_url": "",
        "locale": "",
        "name": "",
        "owner_id": "",
        "phone": "",
        "postal_code": "",
        "revenue_range": "",
        "size": "",
        "state": "",
        "street": "",
        "tags": "",
        "twitter_handle": "",
        "website": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/v2/accounts/:id.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data account_tier_id= \
  --data archived= \
  --data city= \
  --data company_stage_id= \
  --data company_type= \
  --data conversational_name= \
  --data country= \
  --data crm_id= \
  --data crm_id_type= \
  --data custom_fields= \
  --data description= \
  --data do_not_contact= \
  --data domain= \
  --data founded= \
  --data industry= \
  --data linkedin_url= \
  --data locale= \
  --data name= \
  --data owner_id= \
  --data phone= \
  --data postal_code= \
  --data revenue_range= \
  --data size= \
  --data state= \
  --data street= \
  --data tags= \
  --data twitter_handle= \
  --data website=

http --form PUT {{baseUrl}}/v2/accounts/:id.json \
  content-type:application/x-www-form-urlencoded \
  account_tier_id='' \
  archived='' \
  city='' \
  company_stage_id='' \
  company_type='' \
  conversational_name='' \
  country='' \
  crm_id='' \
  crm_id_type='' \
  custom_fields='' \
  description='' \
  do_not_contact='' \
  domain='' \
  founded='' \
  industry='' \
  linkedin_url='' \
  locale='' \
  name='' \
  owner_id='' \
  phone='' \
  postal_code='' \
  revenue_range='' \
  size='' \
  state='' \
  street='' \
  tags='' \
  twitter_handle='' \
  website=''

wget --quiet \
  --method PUT \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'account_tier_id=&archived=&city=&company_stage_id=&company_type=&conversational_name=&country=&crm_id=&crm_id_type=&custom_fields=&description=&do_not_contact=&domain=&founded=&industry=&linkedin_url=&locale=&name=&owner_id=&phone=&postal_code=&revenue_range=&size=&state=&street=&tags=&twitter_handle=&website=' \
  --output-document \
  - {{baseUrl}}/v2/accounts/:id.json

import Foundation

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

let postData = NSMutableData(data: "account_tier_id=".data(using: String.Encoding.utf8)!)
postData.append("&archived=".data(using: String.Encoding.utf8)!)
postData.append("&city=".data(using: String.Encoding.utf8)!)
postData.append("&company_stage_id=".data(using: String.Encoding.utf8)!)
postData.append("&company_type=".data(using: String.Encoding.utf8)!)
postData.append("&conversational_name=".data(using: String.Encoding.utf8)!)
postData.append("&country=".data(using: String.Encoding.utf8)!)
postData.append("&crm_id=".data(using: String.Encoding.utf8)!)
postData.append("&crm_id_type=".data(using: String.Encoding.utf8)!)
postData.append("&custom_fields=".data(using: String.Encoding.utf8)!)
postData.append("&description=".data(using: String.Encoding.utf8)!)
postData.append("&do_not_contact=".data(using: String.Encoding.utf8)!)
postData.append("&domain=".data(using: String.Encoding.utf8)!)
postData.append("&founded=".data(using: String.Encoding.utf8)!)
postData.append("&industry=".data(using: String.Encoding.utf8)!)
postData.append("&linkedin_url=".data(using: String.Encoding.utf8)!)
postData.append("&locale=".data(using: String.Encoding.utf8)!)
postData.append("&name=".data(using: String.Encoding.utf8)!)
postData.append("&owner_id=".data(using: String.Encoding.utf8)!)
postData.append("&phone=".data(using: String.Encoding.utf8)!)
postData.append("&postal_code=".data(using: String.Encoding.utf8)!)
postData.append("&revenue_range=".data(using: String.Encoding.utf8)!)
postData.append("&size=".data(using: String.Encoding.utf8)!)
postData.append("&state=".data(using: String.Encoding.utf8)!)
postData.append("&street=".data(using: String.Encoding.utf8)!)
postData.append("&tags=".data(using: String.Encoding.utf8)!)
postData.append("&twitter_handle=".data(using: String.Encoding.utf8)!)
postData.append("&website=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/accounts/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

GET Fetch a call instructions

{{baseUrl}}/v2/action_details/call_instructions/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/action_details/call_instructions/:id.json");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/action_details/call_instructions/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/action_details/call_instructions/:id.json"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/action_details/call_instructions/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/action_details/call_instructions/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/action_details/call_instructions/:id.json"

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

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

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

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

}

GET /baseUrl/v2/action_details/call_instructions/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/action_details/call_instructions/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/action_details/call_instructions/:id.json"))
    .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}}/v2/action_details/call_instructions/:id.json")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/action_details/call_instructions/:id.json")
  .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}}/v2/action_details/call_instructions/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/action_details/call_instructions/:id.json'
};

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

const url = '{{baseUrl}}/v2/action_details/call_instructions/:id.json';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/action_details/call_instructions/:id.json',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/action_details/call_instructions/:id.json")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/action_details/call_instructions/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/action_details/call_instructions/:id.json'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/action_details/call_instructions/:id.json');

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}}/v2/action_details/call_instructions/:id.json'
};

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

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

const url = '{{baseUrl}}/v2/action_details/call_instructions/:id.json';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/action_details/call_instructions/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/action_details/call_instructions/:id.json" in

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

 "{{baseUrl}}/v2/action_details/call_instructions/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/action_details/call_instructions/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/action_details/call_instructions/:id.json');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/action_details/call_instructions/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/action_details/call_instructions/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/action_details/call_instructions/:id.json' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/action_details/call_instructions/:id.json")

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

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

import requests

url = "{{baseUrl}}/v2/action_details/call_instructions/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/action_details/call_instructions/:id.json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/action_details/call_instructions/:id.json")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/action_details/call_instructions/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/action_details/call_instructions/:id.json";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/action_details/call_instructions/:id.json

http GET {{baseUrl}}/v2/action_details/call_instructions/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/action_details/call_instructions/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/action_details/call_instructions/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET List call instructions

{{baseUrl}}/v2/action_details/call_instructions.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/action_details/call_instructions.json");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/action_details/call_instructions.json")

require "http/client"

url = "{{baseUrl}}/v2/action_details/call_instructions.json"

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

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

var client = new RestClient("{{baseUrl}}/v2/action_details/call_instructions.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/action_details/call_instructions.json"

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

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

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

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

}

GET /baseUrl/v2/action_details/call_instructions.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/action_details/call_instructions.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/action_details/call_instructions.json"))
    .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}}/v2/action_details/call_instructions.json")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/action_details/call_instructions.json")
  .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}}/v2/action_details/call_instructions.json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/action_details/call_instructions.json'
};

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

const url = '{{baseUrl}}/v2/action_details/call_instructions.json';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/action_details/call_instructions.json',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/action_details/call_instructions.json")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/action_details/call_instructions.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/action_details/call_instructions.json'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/action_details/call_instructions.json');

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}}/v2/action_details/call_instructions.json'
};

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

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

const url = '{{baseUrl}}/v2/action_details/call_instructions.json';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/action_details/call_instructions.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/action_details/call_instructions.json" in

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

 "{{baseUrl}}/v2/action_details/call_instructions.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/action_details/call_instructions.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/action_details/call_instructions.json');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/action_details/call_instructions.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/action_details/call_instructions.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/action_details/call_instructions.json' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/action_details/call_instructions.json")

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

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

import requests

url = "{{baseUrl}}/v2/action_details/call_instructions.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/action_details/call_instructions.json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/action_details/call_instructions.json")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/action_details/call_instructions.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/action_details/call_instructions.json";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/action_details/call_instructions.json

http GET {{baseUrl}}/v2/action_details/call_instructions.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/action_details/call_instructions.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/action_details/call_instructions.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET Fetch an action

{{baseUrl}}/v2/actions/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/actions/:id.json");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/actions/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/actions/:id.json"

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

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

var client = new RestClient("{{baseUrl}}/v2/actions/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/actions/:id.json"

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

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

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

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

}

GET /baseUrl/v2/actions/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/actions/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/actions/:id.json"))
    .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}}/v2/actions/:id.json")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/actions/:id.json")
  .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}}/v2/actions/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/actions/:id.json'};

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

const url = '{{baseUrl}}/v2/actions/:id.json';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/actions/:id.json',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/actions/:id.json")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/actions/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/actions/:id.json'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/actions/:id.json');

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}}/v2/actions/:id.json'};

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

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

const url = '{{baseUrl}}/v2/actions/:id.json';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/actions/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/actions/:id.json" in

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

 "{{baseUrl}}/v2/actions/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/actions/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/actions/:id.json');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/actions/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/actions/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/actions/:id.json' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/actions/:id.json")

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

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

import requests

url = "{{baseUrl}}/v2/actions/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/actions/:id.json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/actions/:id.json")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/actions/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/actions/:id.json";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/actions/:id.json

http GET {{baseUrl}}/v2/actions/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/actions/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/actions/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET List actions

{{baseUrl}}/v2/actions.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/actions.json");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/actions.json")

require "http/client"

url = "{{baseUrl}}/v2/actions.json"

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

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

var client = new RestClient("{{baseUrl}}/v2/actions.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/actions.json"

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

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

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

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

}

GET /baseUrl/v2/actions.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/actions.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/actions.json"))
    .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}}/v2/actions.json")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/actions.json")
  .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}}/v2/actions.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/actions.json'};

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

const url = '{{baseUrl}}/v2/actions.json';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/actions.json',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/actions.json")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/actions.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/actions.json'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/actions.json');

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}}/v2/actions.json'};

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

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

const url = '{{baseUrl}}/v2/actions.json';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/actions.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/actions.json" in

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

 "{{baseUrl}}/v2/actions.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/actions.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/actions.json');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/actions.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/actions.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/actions.json' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/actions.json")

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

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

import requests

url = "{{baseUrl}}/v2/actions.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/actions.json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/actions.json")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/actions.json') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/actions.json

http GET {{baseUrl}}/v2/actions.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/actions.json

import Foundation

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

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

dataTask.resume()

POST Create an activity

{{baseUrl}}/v2/activities.json

BODY formUrlEncoded

action_id

task_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/activities.json");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "action_id=&task_id=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/activities.json" {:form-params {:action_id ""
                                                                             :task_id ""}})

require "http/client"

url = "{{baseUrl}}/v2/activities.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "action_id=&task_id="

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

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

var client = new RestClient("{{baseUrl}}/v2/activities.json");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "action_id=&task_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/activities.json"

	payload := strings.NewReader("action_id=&task_id=")

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

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

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

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

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

}

POST /baseUrl/v2/activities.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 19

action_id=&task_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/activities.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("action_id=&task_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "action_id=&task_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/activities.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/activities.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("action_id=&task_id=")
  .asString();

const data = 'action_id=&task_id=';

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

const url = '{{baseUrl}}/v2/activities.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({action_id: '', task_id: ''})
};

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}}/v2/activities.json',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    action_id: '',
    task_id: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "action_id=&task_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/activities.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

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

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

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({action_id: '', task_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/activities.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {action_id: '', task_id: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/activities.json');

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

req.form({
  action_id: '',
  task_id: ''
});

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

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

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

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

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

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

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

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

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

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

#import 

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

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"action_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&task_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/activities.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/activities.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "action_id=&task_id=" in

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

 "{{baseUrl}}/v2/activities.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "action_id=&task_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/activities.json', [
  'form_params' => [
    'action_id' => '',
    'task_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/activities.json');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(new http\QueryString([
  'action_id' => '',
  'task_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/activities.json');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/activities.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'action_id=&task_id='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/activities.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'action_id=&task_id='

import http.client

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

payload = "action_id=&task_id="

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

conn.request("POST", "/baseUrl/v2/activities.json", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/activities.json"

payload = {
    "action_id": "",
    "task_id": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/activities.json"

payload <- "action_id=&task_id="

encode <- "form"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/activities.json")

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

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

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

require 'faraday'

data = {
  :action_id => "",
  :task_id => "",
}

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

response = conn.post('/baseUrl/v2/activities.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "action_id": "",
        "task_id": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/activities.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data action_id= \
  --data task_id=

http --form POST {{baseUrl}}/v2/activities.json \
  content-type:application/x-www-form-urlencoded \
  action_id='' \
  task_id=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'action_id=&task_id=' \
  --output-document \
  - {{baseUrl}}/v2/activities.json

import Foundation

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

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

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

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

dataTask.resume()

GET List Past Activities

{{baseUrl}}/v2/activity_histories

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/activity_histories")

require "http/client"

url = "{{baseUrl}}/v2/activity_histories"

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

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

var client = new RestClient("{{baseUrl}}/v2/activity_histories");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/activity_histories"

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

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

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

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

}

GET /baseUrl/v2/activity_histories HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/activity_histories"))
    .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}}/v2/activity_histories")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/activity_histories")
  .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}}/v2/activity_histories');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/activity_histories'};

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

const url = '{{baseUrl}}/v2/activity_histories';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/activity_histories',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/activity_histories")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/activity_histories',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/activity_histories'};

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

  console.log(body);
});

const unirest = require('unirest');

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

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}}/v2/activity_histories'};

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

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

const url = '{{baseUrl}}/v2/activity_histories';
const options = {method: 'GET'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/activity_histories" in

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

 "{{baseUrl}}/v2/activity_histories",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/activity_histories');

echo $response->getBody();

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

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

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

setRequestUrl('{{baseUrl}}/v2/activity_histories');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/activity_histories' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/activity_histories' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/activity_histories")

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

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

import requests

url = "{{baseUrl}}/v2/activity_histories"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/activity_histories"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/activity_histories")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/activity_histories') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/activity_histories

http GET {{baseUrl}}/v2/activity_histories

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/activity_histories

import Foundation

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

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

dataTask.resume()

POST Create a bulk job

{{baseUrl}}/v2/bulk_jobs

BODY formUrlEncoded

name

type

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "name=&type=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/bulk_jobs" {:form-params {:name ""
                                                                       :type ""}})

require "http/client"

url = "{{baseUrl}}/v2/bulk_jobs"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "name=&type="

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v2/bulk_jobs"

	payload := strings.NewReader("name=&type=")

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

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

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

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

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

}

POST /baseUrl/v2/bulk_jobs HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 11

name=&type=

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/bulk_jobs")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("name=&type=")
  .asString();

const data = 'name=&type=';

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

const url = '{{baseUrl}}/v2/bulk_jobs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({name: '', 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}}/v2/bulk_jobs',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    name: '',
    type: ''
  }
};

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

val client = OkHttpClient()

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

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

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

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

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({name: '', type: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/bulk_jobs',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {name: '', 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}}/v2/bulk_jobs');

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

req.form({
  name: '',
  type: ''
});

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

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

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

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

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

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

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

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

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

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

#import 

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

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&type=" dataUsingEncoding:NSUTF8StringEncoding]];

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/bulk_jobs" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "name=&type=" in

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

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

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/bulk_jobs', [
  'form_params' => [
    'name' => '',
    'type' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(new http\QueryString([
  'name' => '',
  'type' => ''
]));

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

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

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

echo $response->getBody();

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

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

import http.client

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

payload = "name=&type="

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

conn.request("POST", "/baseUrl/v2/bulk_jobs", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/bulk_jobs"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/bulk_jobs"

payload <- "name=&type="

encode <- "form"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/bulk_jobs")

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

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

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

require 'faraday'

data = {
  :name => "",
  :type => "",
}

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "name": "",
        "type": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/bulk_jobs \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data name= \
  --data type=

http --form POST {{baseUrl}}/v2/bulk_jobs \
  content-type:application/x-www-form-urlencoded \
  name='' \
  type=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'name=&type=' \
  --output-document \
  - {{baseUrl}}/v2/bulk_jobs

import Foundation

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

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

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

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

dataTask.resume()

GET Fetch a bulk job

{{baseUrl}}/v2/bulk_jobs/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/bulk_jobs/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/bulk_jobs/:id")

require "http/client"

url = "{{baseUrl}}/v2/bulk_jobs/:id"

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

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

var client = new RestClient("{{baseUrl}}/v2/bulk_jobs/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/bulk_jobs/:id"

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

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

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

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

}

GET /baseUrl/v2/bulk_jobs/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/bulk_jobs/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/bulk_jobs/:id"))
    .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}}/v2/bulk_jobs/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/bulk_jobs/:id")
  .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}}/v2/bulk_jobs/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/bulk_jobs/:id'};

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

const url = '{{baseUrl}}/v2/bulk_jobs/:id';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/bulk_jobs/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/bulk_jobs/:id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/bulk_jobs/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/bulk_jobs/:id'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/bulk_jobs/:id');

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}}/v2/bulk_jobs/:id'};

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

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

const url = '{{baseUrl}}/v2/bulk_jobs/:id';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/bulk_jobs/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/bulk_jobs/:id" in

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

 "{{baseUrl}}/v2/bulk_jobs/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/bulk_jobs/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/bulk_jobs/:id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/bulk_jobs/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/bulk_jobs/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/bulk_jobs/:id' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/bulk_jobs/:id")

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

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

import requests

url = "{{baseUrl}}/v2/bulk_jobs/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/bulk_jobs/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/bulk_jobs/:id")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/bulk_jobs/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/bulk_jobs/:id

http GET {{baseUrl}}/v2/bulk_jobs/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/bulk_jobs/:id

import Foundation

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

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

dataTask.resume()

GET List bulk jobs

{{baseUrl}}/v2/bulk_jobs

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/bulk_jobs")

require "http/client"

url = "{{baseUrl}}/v2/bulk_jobs"

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

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

var client = new RestClient("{{baseUrl}}/v2/bulk_jobs");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/bulk_jobs"

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

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

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

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

}

GET /baseUrl/v2/bulk_jobs HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/bulk_jobs"))
    .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}}/v2/bulk_jobs")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/bulk_jobs")
  .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}}/v2/bulk_jobs');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/bulk_jobs'};

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

const url = '{{baseUrl}}/v2/bulk_jobs';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/bulk_jobs',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/bulk_jobs")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/bulk_jobs',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/bulk_jobs'};

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

  console.log(body);
});

const unirest = require('unirest');

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

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}}/v2/bulk_jobs'};

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

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

const url = '{{baseUrl}}/v2/bulk_jobs';
const options = {method: 'GET'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/bulk_jobs" in

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

 "{{baseUrl}}/v2/bulk_jobs",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/bulk_jobs');

echo $response->getBody();

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

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

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

setRequestUrl('{{baseUrl}}/v2/bulk_jobs');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/bulk_jobs' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/bulk_jobs' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/bulk_jobs")

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

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

import requests

url = "{{baseUrl}}/v2/bulk_jobs"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/bulk_jobs"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/bulk_jobs")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/bulk_jobs') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/bulk_jobs

http GET {{baseUrl}}/v2/bulk_jobs

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/bulk_jobs

import Foundation

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

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

dataTask.resume()

PUT Update a bulk job

{{baseUrl}}/v2/bulk_jobs/:id

QUERY PARAMS

BODY formUrlEncoded

name

ready_to_execute

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/bulk_jobs/:id");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "name=&ready_to_execute=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/v2/bulk_jobs/:id" {:form-params {:name ""
                                                                          :ready_to_execute ""}})

require "http/client"

url = "{{baseUrl}}/v2/bulk_jobs/:id"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "name=&ready_to_execute="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v2/bulk_jobs/:id"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "name", "" },
        { "ready_to_execute", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/bulk_jobs/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "name=&ready_to_execute=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/bulk_jobs/:id"

	payload := strings.NewReader("name=&ready_to_execute=")

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

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

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

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

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

}

PUT /baseUrl/v2/bulk_jobs/:id HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 23

name=&ready_to_execute=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v2/bulk_jobs/:id")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("name=&ready_to_execute=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/bulk_jobs/:id"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("PUT", HttpRequest.BodyPublishers.ofString("name=&ready_to_execute="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "name=&ready_to_execute=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/bulk_jobs/:id")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/v2/bulk_jobs/:id")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("name=&ready_to_execute=")
  .asString();

const data = 'name=&ready_to_execute=';

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

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

xhr.open('PUT', '{{baseUrl}}/v2/bulk_jobs/:id');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/bulk_jobs/:id',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/v2/bulk_jobs/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({name: '', ready_to_execute: ''})
};

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}}/v2/bulk_jobs/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    name: '',
    ready_to_execute: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "name=&ready_to_execute=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/bulk_jobs/:id")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

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

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

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({name: '', ready_to_execute: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/bulk_jobs/:id',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {name: '', ready_to_execute: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/v2/bulk_jobs/:id');

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

req.form({
  name: '',
  ready_to_execute: ''
});

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

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');
encodedParams.set('ready_to_execute', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/bulk_jobs/:id',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');
encodedParams.set('ready_to_execute', '');

const url = '{{baseUrl}}/v2/bulk_jobs/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&ready_to_execute=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/bulk_jobs/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/bulk_jobs/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "name=&ready_to_execute=" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/bulk_jobs/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => "name=&ready_to_execute=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/v2/bulk_jobs/:id', [
  'form_params' => [
    'name' => '',
    'ready_to_execute' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/bulk_jobs/:id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'name' => '',
  'ready_to_execute' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'name' => '',
  'ready_to_execute' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/bulk_jobs/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/bulk_jobs/:id' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'name=&ready_to_execute='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/bulk_jobs/:id' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'name=&ready_to_execute='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "name=&ready_to_execute="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PUT", "/baseUrl/v2/bulk_jobs/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/bulk_jobs/:id"

payload = {
    "name": "",
    "ready_to_execute": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.put(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/bulk_jobs/:id"

payload <- "name=&ready_to_execute="

encode <- "form"

response <- VERB("PUT", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/bulk_jobs/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "name=&ready_to_execute="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :name => "",
  :ready_to_execute => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.put('/baseUrl/v2/bulk_jobs/:id') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/bulk_jobs/:id";

    let payload = json!({
        "name": "",
        "ready_to_execute": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/v2/bulk_jobs/:id \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data name= \
  --data ready_to_execute=

http --form PUT {{baseUrl}}/v2/bulk_jobs/:id \
  content-type:application/x-www-form-urlencoded \
  name='' \
  ready_to_execute=''

wget --quiet \
  --method PUT \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'name=&ready_to_execute=' \
  --output-document \
  - {{baseUrl}}/v2/bulk_jobs/:id

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "name=".data(using: String.Encoding.utf8)!)
postData.append("&ready_to_execute=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/bulk_jobs/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create job data for a bulk job

{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data

QUERY PARAMS

bulk_jobs_id

BODY formUrlEncoded

data

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "data=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data" {:form-params {:data ""}})

require "http/client"

url = "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "data="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "data", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "data=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data"

	payload := strings.NewReader("data=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/bulk_jobs/:bulk_jobs_id/job_data HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 5

data=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("data=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("data="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "data=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("data=")
  .asString();

const data = 'data=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('data', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({data: ''})
};

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}}/v2/bulk_jobs/:bulk_jobs_id/job_data',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    data: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "data=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/bulk_jobs/:bulk_jobs_id/job_data',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({data: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {data: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  data: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('data', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('data', '');

const url = '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"data=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "data=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "data=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data', [
  'form_params' => [
    'data' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'data' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'data' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'data='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'data='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "data="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/bulk_jobs/:bulk_jobs_id/job_data", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data"

payload = { "data": "" }
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data"

payload <- "data="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "data="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :data => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/bulk_jobs/:bulk_jobs_id/job_data') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data";

    let payload = json!({"data": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data data=

http --form POST {{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data \
  content-type:application/x-www-form-urlencoded \
  data=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data data= \
  --output-document \
  - {{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "data=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List job data for a bulk job

{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data

QUERY PARAMS

bulk_jobs_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data")

require "http/client"

url = "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/bulk_jobs/:bulk_jobs_id/job_data HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data"))
    .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}}/v2/bulk_jobs/:bulk_jobs_id/job_data")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data")
  .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}}/v2/bulk_jobs/:bulk_jobs_id/job_data');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/bulk_jobs/:bulk_jobs_id/job_data',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data');

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}}/v2/bulk_jobs/:bulk_jobs_id/job_data'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/bulk_jobs/:bulk_jobs_id/job_data")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/bulk_jobs/:bulk_jobs_id/job_data') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data

http GET {{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/job_data")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List job data for a completed bulk job.

{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results

QUERY PARAMS

bulk_jobs_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results")

require "http/client"

url = "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/bulk_jobs/:bulk_jobs_id/results HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results"))
    .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}}/v2/bulk_jobs/:bulk_jobs_id/results")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results")
  .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}}/v2/bulk_jobs/:bulk_jobs_id/results');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/bulk_jobs/:bulk_jobs_id/results',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results');

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}}/v2/bulk_jobs/:bulk_jobs_id/results'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/bulk_jobs/:bulk_jobs_id/results")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/bulk_jobs/:bulk_jobs_id/results') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results

http GET {{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/bulk_jobs/:bulk_jobs_id/results")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Export a cadence

{{baseUrl}}/v2/cadence_exports/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/cadence_exports/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/cadence_exports/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/cadence_exports/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/cadence_exports/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/cadence_exports/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/cadence_exports/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/cadence_exports/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/cadence_exports/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/cadence_exports/:id.json"))
    .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}}/v2/cadence_exports/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/cadence_exports/:id.json")
  .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}}/v2/cadence_exports/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/cadence_exports/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/cadence_exports/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/cadence_exports/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/cadence_exports/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/cadence_exports/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/cadence_exports/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/cadence_exports/:id.json');

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}}/v2/cadence_exports/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/cadence_exports/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/cadence_exports/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/cadence_exports/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/cadence_exports/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/cadence_exports/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/cadence_exports/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/cadence_exports/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/cadence_exports/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/cadence_exports/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/cadence_exports/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/cadence_exports/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/cadence_exports/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/cadence_exports/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/cadence_exports/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/cadence_exports/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/cadence_exports/:id.json

http GET {{baseUrl}}/v2/cadence_exports/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/cadence_exports/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/cadence_exports/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Import cadences from JSON

{{baseUrl}}/v2/cadence_imports.json

BODY formUrlEncoded

cadence_content

settings

sharing_settings

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/cadence_imports.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "cadence_content=&settings=&sharing_settings=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/cadence_imports.json" {:form-params {:cadence_content ""
                                                                                  :settings ""
                                                                                  :sharing_settings ""}})

require "http/client"

url = "{{baseUrl}}/v2/cadence_imports.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "cadence_content=&settings=&sharing_settings="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/cadence_imports.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "cadence_content", "" },
        { "settings", "" },
        { "sharing_settings", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/cadence_imports.json");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "cadence_content=&settings=&sharing_settings=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/cadence_imports.json"

	payload := strings.NewReader("cadence_content=&settings=&sharing_settings=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/cadence_imports.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 44

cadence_content=&settings=&sharing_settings=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/cadence_imports.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("cadence_content=&settings=&sharing_settings=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/cadence_imports.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("cadence_content=&settings=&sharing_settings="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "cadence_content=&settings=&sharing_settings=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/cadence_imports.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/cadence_imports.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("cadence_content=&settings=&sharing_settings=")
  .asString();

const data = 'cadence_content=&settings=&sharing_settings=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/cadence_imports.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('cadence_content', '');
encodedParams.set('settings', '');
encodedParams.set('sharing_settings', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/cadence_imports.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/cadence_imports.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({cadence_content: '', settings: '', sharing_settings: ''})
};

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}}/v2/cadence_imports.json',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    cadence_content: '',
    settings: '',
    sharing_settings: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "cadence_content=&settings=&sharing_settings=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/cadence_imports.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/cadence_imports.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({cadence_content: '', settings: '', sharing_settings: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/cadence_imports.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {cadence_content: '', settings: '', sharing_settings: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/cadence_imports.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  cadence_content: '',
  settings: '',
  sharing_settings: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('cadence_content', '');
encodedParams.set('settings', '');
encodedParams.set('sharing_settings', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/cadence_imports.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('cadence_content', '');
encodedParams.set('settings', '');
encodedParams.set('sharing_settings', '');

const url = '{{baseUrl}}/v2/cadence_imports.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"cadence_content=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&settings=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&sharing_settings=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/cadence_imports.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/cadence_imports.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "cadence_content=&settings=&sharing_settings=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/cadence_imports.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "cadence_content=&settings=&sharing_settings=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/cadence_imports.json', [
  'form_params' => [
    'cadence_content' => '',
    'settings' => '',
    'sharing_settings' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/cadence_imports.json');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'cadence_content' => '',
  'settings' => '',
  'sharing_settings' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'cadence_content' => '',
  'settings' => '',
  'sharing_settings' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/cadence_imports.json');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/cadence_imports.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'cadence_content=&settings=&sharing_settings='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/cadence_imports.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'cadence_content=&settings=&sharing_settings='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "cadence_content=&settings=&sharing_settings="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/cadence_imports.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/cadence_imports.json"

payload = {
    "cadence_content": "",
    "settings": "",
    "sharing_settings": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/cadence_imports.json"

payload <- "cadence_content=&settings=&sharing_settings="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/cadence_imports.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "cadence_content=&settings=&sharing_settings="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :cadence_content => "",
  :settings => "",
  :sharing_settings => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/cadence_imports.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/cadence_imports.json";

    let payload = json!({
        "cadence_content": "",
        "settings": "",
        "sharing_settings": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/cadence_imports.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data cadence_content= \
  --data settings= \
  --data sharing_settings=

http --form POST {{baseUrl}}/v2/cadence_imports.json \
  content-type:application/x-www-form-urlencoded \
  cadence_content='' \
  settings='' \
  sharing_settings=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'cadence_content=&settings=&sharing_settings=' \
  --output-document \
  - {{baseUrl}}/v2/cadence_imports.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "cadence_content=".data(using: String.Encoding.utf8)!)
postData.append("&settings=".data(using: String.Encoding.utf8)!)
postData.append("&sharing_settings=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/cadence_imports.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create a cadence membership

{{baseUrl}}/v2/cadence_memberships.json

QUERY PARAMS

person_id

cadence_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/cadence_memberships.json" {:query-params {:person_id ""
                                                                                       :cadence_id ""}})

require "http/client"

url = "{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/cadence_memberships.json?person_id=&cadence_id= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id="))
    .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}}/v2/cadence_memberships.json?person_id=&cadence_id=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id=")
  .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}}/v2/cadence_memberships.json?person_id=&cadence_id=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/cadence_memberships.json',
  params: {person_id: '', cadence_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id=';
const options = {method: 'POST'};

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}}/v2/cadence_memberships.json?person_id=&cadence_id=',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/cadence_memberships.json?person_id=&cadence_id=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/cadence_memberships.json',
  qs: {person_id: '', cadence_id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/cadence_memberships.json');

req.query({
  person_id: '',
  cadence_id: ''
});

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}}/v2/cadence_memberships.json',
  params: {person_id: '', cadence_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/v2/cadence_memberships.json?person_id=&cadence_id=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/cadence_memberships.json');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'person_id' => '',
  'cadence_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/cadence_memberships.json');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'person_id' => '',
  'cadence_id' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/v2/cadence_memberships.json?person_id=&cadence_id=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/cadence_memberships.json"

querystring = {"person_id":"","cadence_id":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/cadence_memberships.json"

queryString <- list(
  person_id = "",
  cadence_id = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/v2/cadence_memberships.json') do |req|
  req.params['person_id'] = ''
  req.params['cadence_id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/cadence_memberships.json";

    let querystring = [
        ("person_id", ""),
        ("cadence_id", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id='

http POST '{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/cadence_memberships.json?person_id=&cadence_id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 Delete a cadence membership

{{baseUrl}}/v2/cadence_memberships/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/cadence_memberships/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v2/cadence_memberships/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/cadence_memberships/:id.json"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v2/cadence_memberships/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/cadence_memberships/:id.json");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/cadence_memberships/:id.json"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v2/cadence_memberships/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/cadence_memberships/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/cadence_memberships/:id.json"))
    .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}}/v2/cadence_memberships/:id.json")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v2/cadence_memberships/:id.json")
  .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}}/v2/cadence_memberships/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v2/cadence_memberships/:id.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/cadence_memberships/:id.json';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/cadence_memberships/:id.json',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/cadence_memberships/:id.json")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/cadence_memberships/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v2/cadence_memberships/:id.json'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/cadence_memberships/:id.json');

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}}/v2/cadence_memberships/:id.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/cadence_memberships/:id.json';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/cadence_memberships/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/cadence_memberships/:id.json" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/cadence_memberships/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v2/cadence_memberships/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/cadence_memberships/:id.json');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/cadence_memberships/:id.json');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/cadence_memberships/:id.json' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/cadence_memberships/:id.json' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v2/cadence_memberships/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/cadence_memberships/:id.json"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/cadence_memberships/:id.json"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/cadence_memberships/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v2/cadence_memberships/:id.json') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/cadence_memberships/:id.json";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v2/cadence_memberships/:id.json

http DELETE {{baseUrl}}/v2/cadence_memberships/:id.json

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/cadence_memberships/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/cadence_memberships/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch a cadence membership

{{baseUrl}}/v2/cadence_memberships/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/cadence_memberships/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/cadence_memberships/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/cadence_memberships/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/cadence_memberships/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/cadence_memberships/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/cadence_memberships/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/cadence_memberships/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/cadence_memberships/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/cadence_memberships/:id.json"))
    .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}}/v2/cadence_memberships/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/cadence_memberships/:id.json")
  .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}}/v2/cadence_memberships/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/cadence_memberships/:id.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/cadence_memberships/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/cadence_memberships/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/cadence_memberships/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/cadence_memberships/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/cadence_memberships/:id.json'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/cadence_memberships/:id.json');

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}}/v2/cadence_memberships/:id.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/cadence_memberships/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/cadence_memberships/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/cadence_memberships/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/cadence_memberships/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/cadence_memberships/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/cadence_memberships/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/cadence_memberships/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/cadence_memberships/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/cadence_memberships/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/cadence_memberships/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/cadence_memberships/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/cadence_memberships/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/cadence_memberships/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/cadence_memberships/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/cadence_memberships/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/cadence_memberships/:id.json

http GET {{baseUrl}}/v2/cadence_memberships/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/cadence_memberships/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/cadence_memberships/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List cadence memberships

{{baseUrl}}/v2/cadence_memberships.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/cadence_memberships.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/cadence_memberships.json")

require "http/client"

url = "{{baseUrl}}/v2/cadence_memberships.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/cadence_memberships.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/cadence_memberships.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/cadence_memberships.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/cadence_memberships.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/cadence_memberships.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/cadence_memberships.json"))
    .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}}/v2/cadence_memberships.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/cadence_memberships.json")
  .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}}/v2/cadence_memberships.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/cadence_memberships.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/cadence_memberships.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/cadence_memberships.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/cadence_memberships.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/cadence_memberships.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/cadence_memberships.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/cadence_memberships.json');

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}}/v2/cadence_memberships.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/cadence_memberships.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/cadence_memberships.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/cadence_memberships.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/cadence_memberships.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/cadence_memberships.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/cadence_memberships.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/cadence_memberships.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/cadence_memberships.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/cadence_memberships.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/cadence_memberships.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/cadence_memberships.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/cadence_memberships.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/cadence_memberships.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/cadence_memberships.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/cadence_memberships.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/cadence_memberships.json

http GET {{baseUrl}}/v2/cadence_memberships.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/cadence_memberships.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/cadence_memberships.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch a cadence

{{baseUrl}}/v2/cadences/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/cadences/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/cadences/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/cadences/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/cadences/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/cadences/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/cadences/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/cadences/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/cadences/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/cadences/:id.json"))
    .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}}/v2/cadences/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/cadences/:id.json")
  .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}}/v2/cadences/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/cadences/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/cadences/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/cadences/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/cadences/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/cadences/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/cadences/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/cadences/:id.json');

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}}/v2/cadences/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/cadences/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/cadences/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/cadences/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/cadences/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/cadences/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/cadences/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/cadences/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/cadences/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/cadences/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/cadences/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/cadences/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/cadences/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/cadences/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/cadences/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/cadences/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/cadences/:id.json

http GET {{baseUrl}}/v2/cadences/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/cadences/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/cadences/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List cadences

{{baseUrl}}/v2/cadences.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/cadences.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/cadences.json")

require "http/client"

url = "{{baseUrl}}/v2/cadences.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/cadences.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/cadences.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/cadences.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/cadences.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/cadences.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/cadences.json"))
    .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}}/v2/cadences.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/cadences.json")
  .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}}/v2/cadences.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/cadences.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/cadences.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/cadences.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/cadences.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/cadences.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/cadences.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/cadences.json');

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}}/v2/cadences.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/cadences.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/cadences.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/cadences.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/cadences.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/cadences.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/cadences.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/cadences.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/cadences.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/cadences.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/cadences.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/cadences.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/cadences.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/cadences.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/cadences.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/cadences.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/cadences.json

http GET {{baseUrl}}/v2/cadences.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/cadences.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/cadences.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List calendar events

{{baseUrl}}/v2/calendar/events

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/calendar/events");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/calendar/events")

require "http/client"

url = "{{baseUrl}}/v2/calendar/events"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/calendar/events"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/calendar/events");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/calendar/events"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/calendar/events HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/calendar/events")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/calendar/events"))
    .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}}/v2/calendar/events")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/calendar/events")
  .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}}/v2/calendar/events');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/calendar/events'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/calendar/events';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/calendar/events',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/calendar/events")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/calendar/events',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/calendar/events'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/calendar/events');

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}}/v2/calendar/events'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/calendar/events';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/calendar/events"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/calendar/events" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/calendar/events",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/calendar/events');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/calendar/events');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/calendar/events');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/calendar/events' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/calendar/events' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/calendar/events")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/calendar/events"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/calendar/events"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/calendar/events")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/calendar/events') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/calendar/events";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/calendar/events

http GET {{baseUrl}}/v2/calendar/events

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/calendar/events

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/calendar/events")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Upsert a calendar event

{{baseUrl}}/v2/calendar/events/upsert

BODY formUrlEncoded

all_day

attendees

calendar_id

canceled_at

description

end_time

i_cal_uid

location

organizer

recurring

start_time

status

title

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/calendar/events/upsert");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "all_day=&attendees=&calendar_id=&canceled_at=&description=&end_time=&i_cal_uid=&id=&location=&organizer=&recurring=&start_time=&status=&title=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/calendar/events/upsert" {:form-params {:all_day ""
                                                                                    :attendees ""
                                                                                    :calendar_id ""
                                                                                    :canceled_at ""
                                                                                    :description ""
                                                                                    :end_time ""
                                                                                    :i_cal_uid ""
                                                                                    :id ""
                                                                                    :location ""
                                                                                    :organizer ""
                                                                                    :recurring ""
                                                                                    :start_time ""
                                                                                    :status ""
                                                                                    :title ""}})

require "http/client"

url = "{{baseUrl}}/v2/calendar/events/upsert"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "all_day=&attendees=&calendar_id=&canceled_at=&description=&end_time=&i_cal_uid=&id=&location=&organizer=&recurring=&start_time=&status=&title="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/calendar/events/upsert"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "all_day", "" },
        { "attendees", "" },
        { "calendar_id", "" },
        { "canceled_at", "" },
        { "description", "" },
        { "end_time", "" },
        { "i_cal_uid", "" },
        { "id", "" },
        { "location", "" },
        { "organizer", "" },
        { "recurring", "" },
        { "start_time", "" },
        { "status", "" },
        { "title", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/calendar/events/upsert");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "all_day=&attendees=&calendar_id=&canceled_at=&description=&end_time=&i_cal_uid=&id=&location=&organizer=&recurring=&start_time=&status=&title=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/calendar/events/upsert"

	payload := strings.NewReader("all_day=&attendees=&calendar_id=&canceled_at=&description=&end_time=&i_cal_uid=&id=&location=&organizer=&recurring=&start_time=&status=&title=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/calendar/events/upsert HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 142

all_day=&attendees=&calendar_id=&canceled_at=&description=&end_time=&i_cal_uid=&id=&location=&organizer=&recurring=&start_time=&status=&title=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/calendar/events/upsert")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("all_day=&attendees=&calendar_id=&canceled_at=&description=&end_time=&i_cal_uid=&id=&location=&organizer=&recurring=&start_time=&status=&title=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/calendar/events/upsert"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("all_day=&attendees=&calendar_id=&canceled_at=&description=&end_time=&i_cal_uid=&id=&location=&organizer=&recurring=&start_time=&status=&title="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "all_day=&attendees=&calendar_id=&canceled_at=&description=&end_time=&i_cal_uid=&id=&location=&organizer=&recurring=&start_time=&status=&title=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/calendar/events/upsert")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/calendar/events/upsert")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("all_day=&attendees=&calendar_id=&canceled_at=&description=&end_time=&i_cal_uid=&id=&location=&organizer=&recurring=&start_time=&status=&title=")
  .asString();

const data = 'all_day=&attendees=&calendar_id=&canceled_at=&description=&end_time=&i_cal_uid=&id=&location=&organizer=&recurring=&start_time=&status=&title=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/calendar/events/upsert');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('all_day', '');
encodedParams.set('attendees', '');
encodedParams.set('calendar_id', '');
encodedParams.set('canceled_at', '');
encodedParams.set('description', '');
encodedParams.set('end_time', '');
encodedParams.set('i_cal_uid', '');
encodedParams.set('id', '');
encodedParams.set('location', '');
encodedParams.set('organizer', '');
encodedParams.set('recurring', '');
encodedParams.set('start_time', '');
encodedParams.set('status', '');
encodedParams.set('title', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/calendar/events/upsert',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/calendar/events/upsert';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    all_day: '',
    attendees: '',
    calendar_id: '',
    canceled_at: '',
    description: '',
    end_time: '',
    i_cal_uid: '',
    id: '',
    location: '',
    organizer: '',
    recurring: '',
    start_time: '',
    status: '',
    title: ''
  })
};

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}}/v2/calendar/events/upsert',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    all_day: '',
    attendees: '',
    calendar_id: '',
    canceled_at: '',
    description: '',
    end_time: '',
    i_cal_uid: '',
    id: '',
    location: '',
    organizer: '',
    recurring: '',
    start_time: '',
    status: '',
    title: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "all_day=&attendees=&calendar_id=&canceled_at=&description=&end_time=&i_cal_uid=&id=&location=&organizer=&recurring=&start_time=&status=&title=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/calendar/events/upsert")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/calendar/events/upsert',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({
  all_day: '',
  attendees: '',
  calendar_id: '',
  canceled_at: '',
  description: '',
  end_time: '',
  i_cal_uid: '',
  id: '',
  location: '',
  organizer: '',
  recurring: '',
  start_time: '',
  status: '',
  title: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/calendar/events/upsert',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    all_day: '',
    attendees: '',
    calendar_id: '',
    canceled_at: '',
    description: '',
    end_time: '',
    i_cal_uid: '',
    id: '',
    location: '',
    organizer: '',
    recurring: '',
    start_time: '',
    status: '',
    title: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/calendar/events/upsert');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  all_day: '',
  attendees: '',
  calendar_id: '',
  canceled_at: '',
  description: '',
  end_time: '',
  i_cal_uid: '',
  id: '',
  location: '',
  organizer: '',
  recurring: '',
  start_time: '',
  status: '',
  title: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('all_day', '');
encodedParams.set('attendees', '');
encodedParams.set('calendar_id', '');
encodedParams.set('canceled_at', '');
encodedParams.set('description', '');
encodedParams.set('end_time', '');
encodedParams.set('i_cal_uid', '');
encodedParams.set('id', '');
encodedParams.set('location', '');
encodedParams.set('organizer', '');
encodedParams.set('recurring', '');
encodedParams.set('start_time', '');
encodedParams.set('status', '');
encodedParams.set('title', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/calendar/events/upsert',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('all_day', '');
encodedParams.set('attendees', '');
encodedParams.set('calendar_id', '');
encodedParams.set('canceled_at', '');
encodedParams.set('description', '');
encodedParams.set('end_time', '');
encodedParams.set('i_cal_uid', '');
encodedParams.set('id', '');
encodedParams.set('location', '');
encodedParams.set('organizer', '');
encodedParams.set('recurring', '');
encodedParams.set('start_time', '');
encodedParams.set('status', '');
encodedParams.set('title', '');

const url = '{{baseUrl}}/v2/calendar/events/upsert';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"all_day=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&attendees=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&calendar_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&canceled_at=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&description=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&end_time=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&i_cal_uid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&location=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&organizer=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&recurring=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&start_time=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&status=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&title=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/calendar/events/upsert"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/calendar/events/upsert" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "all_day=&attendees=&calendar_id=&canceled_at=&description=&end_time=&i_cal_uid=&id=&location=&organizer=&recurring=&start_time=&status=&title=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/calendar/events/upsert",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "all_day=&attendees=&calendar_id=&canceled_at=&description=&end_time=&i_cal_uid=&id=&location=&organizer=&recurring=&start_time=&status=&title=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/calendar/events/upsert', [
  'form_params' => [
    'all_day' => '',
    'attendees' => '',
    'calendar_id' => '',
    'canceled_at' => '',
    'description' => '',
    'end_time' => '',
    'i_cal_uid' => '',
    'id' => '',
    'location' => '',
    'organizer' => '',
    'recurring' => '',
    'start_time' => '',
    'status' => '',
    'title' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/calendar/events/upsert');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'all_day' => '',
  'attendees' => '',
  'calendar_id' => '',
  'canceled_at' => '',
  'description' => '',
  'end_time' => '',
  'i_cal_uid' => '',
  'id' => '',
  'location' => '',
  'organizer' => '',
  'recurring' => '',
  'start_time' => '',
  'status' => '',
  'title' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'all_day' => '',
  'attendees' => '',
  'calendar_id' => '',
  'canceled_at' => '',
  'description' => '',
  'end_time' => '',
  'i_cal_uid' => '',
  'id' => '',
  'location' => '',
  'organizer' => '',
  'recurring' => '',
  'start_time' => '',
  'status' => '',
  'title' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/calendar/events/upsert');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/calendar/events/upsert' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'all_day=&attendees=&calendar_id=&canceled_at=&description=&end_time=&i_cal_uid=&id=&location=&organizer=&recurring=&start_time=&status=&title='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/calendar/events/upsert' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'all_day=&attendees=&calendar_id=&canceled_at=&description=&end_time=&i_cal_uid=&id=&location=&organizer=&recurring=&start_time=&status=&title='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "all_day=&attendees=&calendar_id=&canceled_at=&description=&end_time=&i_cal_uid=&id=&location=&organizer=&recurring=&start_time=&status=&title="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/calendar/events/upsert", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/calendar/events/upsert"

payload = {
    "all_day": "",
    "attendees": "",
    "calendar_id": "",
    "canceled_at": "",
    "description": "",
    "end_time": "",
    "i_cal_uid": "",
    "id": "",
    "location": "",
    "organizer": "",
    "recurring": "",
    "start_time": "",
    "status": "",
    "title": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/calendar/events/upsert"

payload <- "all_day=&attendees=&calendar_id=&canceled_at=&description=&end_time=&i_cal_uid=&id=&location=&organizer=&recurring=&start_time=&status=&title="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/calendar/events/upsert")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "all_day=&attendees=&calendar_id=&canceled_at=&description=&end_time=&i_cal_uid=&id=&location=&organizer=&recurring=&start_time=&status=&title="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :all_day => "",
  :attendees => "",
  :calendar_id => "",
  :canceled_at => "",
  :description => "",
  :end_time => "",
  :i_cal_uid => "",
  :id => "",
  :location => "",
  :organizer => "",
  :recurring => "",
  :start_time => "",
  :status => "",
  :title => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/calendar/events/upsert') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/calendar/events/upsert";

    let payload = json!({
        "all_day": "",
        "attendees": "",
        "calendar_id": "",
        "canceled_at": "",
        "description": "",
        "end_time": "",
        "i_cal_uid": "",
        "id": "",
        "location": "",
        "organizer": "",
        "recurring": "",
        "start_time": "",
        "status": "",
        "title": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/calendar/events/upsert \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data all_day= \
  --data attendees= \
  --data calendar_id= \
  --data canceled_at= \
  --data description= \
  --data end_time= \
  --data i_cal_uid= \
  --data id= \
  --data location= \
  --data organizer= \
  --data recurring= \
  --data start_time= \
  --data status= \
  --data title=

http --form POST {{baseUrl}}/v2/calendar/events/upsert \
  content-type:application/x-www-form-urlencoded \
  all_day='' \
  attendees='' \
  calendar_id='' \
  canceled_at='' \
  description='' \
  end_time='' \
  i_cal_uid='' \
  id='' \
  location='' \
  organizer='' \
  recurring='' \
  start_time='' \
  status='' \
  title=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'all_day=&attendees=&calendar_id=&canceled_at=&description=&end_time=&i_cal_uid=&id=&location=&organizer=&recurring=&start_time=&status=&title=' \
  --output-document \
  - {{baseUrl}}/v2/calendar/events/upsert

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "all_day=".data(using: String.Encoding.utf8)!)
postData.append("&attendees=".data(using: String.Encoding.utf8)!)
postData.append("&calendar_id=".data(using: String.Encoding.utf8)!)
postData.append("&canceled_at=".data(using: String.Encoding.utf8)!)
postData.append("&description=".data(using: String.Encoding.utf8)!)
postData.append("&end_time=".data(using: String.Encoding.utf8)!)
postData.append("&i_cal_uid=".data(using: String.Encoding.utf8)!)
postData.append("&id=".data(using: String.Encoding.utf8)!)
postData.append("&location=".data(using: String.Encoding.utf8)!)
postData.append("&organizer=".data(using: String.Encoding.utf8)!)
postData.append("&recurring=".data(using: String.Encoding.utf8)!)
postData.append("&start_time=".data(using: String.Encoding.utf8)!)
postData.append("&status=".data(using: String.Encoding.utf8)!)
postData.append("&title=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/calendar/events/upsert")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch a call data record

{{baseUrl}}/v2/call_data_records/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/call_data_records/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/call_data_records/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/call_data_records/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/call_data_records/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/call_data_records/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/call_data_records/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/call_data_records/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/call_data_records/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/call_data_records/:id.json"))
    .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}}/v2/call_data_records/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/call_data_records/:id.json")
  .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}}/v2/call_data_records/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/call_data_records/:id.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/call_data_records/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/call_data_records/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/call_data_records/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/call_data_records/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/call_data_records/:id.json'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/call_data_records/:id.json');

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}}/v2/call_data_records/:id.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/call_data_records/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/call_data_records/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/call_data_records/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/call_data_records/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/call_data_records/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/call_data_records/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/call_data_records/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/call_data_records/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/call_data_records/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/call_data_records/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/call_data_records/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/call_data_records/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/call_data_records/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/call_data_records/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/call_data_records/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/call_data_records/:id.json

http GET {{baseUrl}}/v2/call_data_records/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/call_data_records/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/call_data_records/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List call data records

{{baseUrl}}/v2/call_data_records.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/call_data_records.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/call_data_records.json")

require "http/client"

url = "{{baseUrl}}/v2/call_data_records.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/call_data_records.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/call_data_records.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/call_data_records.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/call_data_records.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/call_data_records.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/call_data_records.json"))
    .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}}/v2/call_data_records.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/call_data_records.json")
  .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}}/v2/call_data_records.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/call_data_records.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/call_data_records.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/call_data_records.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/call_data_records.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/call_data_records.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/call_data_records.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/call_data_records.json');

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}}/v2/call_data_records.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/call_data_records.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/call_data_records.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/call_data_records.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/call_data_records.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/call_data_records.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/call_data_records.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/call_data_records.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/call_data_records.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/call_data_records.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/call_data_records.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/call_data_records.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/call_data_records.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/call_data_records.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/call_data_records.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/call_data_records.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/call_data_records.json

http GET {{baseUrl}}/v2/call_data_records.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/call_data_records.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/call_data_records.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List call dispositions

{{baseUrl}}/v2/call_dispositions.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/call_dispositions.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/call_dispositions.json")

require "http/client"

url = "{{baseUrl}}/v2/call_dispositions.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/call_dispositions.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/call_dispositions.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/call_dispositions.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/call_dispositions.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/call_dispositions.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/call_dispositions.json"))
    .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}}/v2/call_dispositions.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/call_dispositions.json")
  .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}}/v2/call_dispositions.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/call_dispositions.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/call_dispositions.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/call_dispositions.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/call_dispositions.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/call_dispositions.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/call_dispositions.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/call_dispositions.json');

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}}/v2/call_dispositions.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/call_dispositions.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/call_dispositions.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/call_dispositions.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/call_dispositions.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/call_dispositions.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/call_dispositions.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/call_dispositions.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/call_dispositions.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/call_dispositions.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/call_dispositions.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/call_dispositions.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/call_dispositions.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/call_dispositions.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/call_dispositions.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/call_dispositions.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/call_dispositions.json

http GET {{baseUrl}}/v2/call_dispositions.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/call_dispositions.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/call_dispositions.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List call sentiments

{{baseUrl}}/v2/call_sentiments.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/call_sentiments.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/call_sentiments.json")

require "http/client"

url = "{{baseUrl}}/v2/call_sentiments.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/call_sentiments.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/call_sentiments.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/call_sentiments.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/call_sentiments.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/call_sentiments.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/call_sentiments.json"))
    .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}}/v2/call_sentiments.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/call_sentiments.json")
  .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}}/v2/call_sentiments.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/call_sentiments.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/call_sentiments.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/call_sentiments.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/call_sentiments.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/call_sentiments.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/call_sentiments.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/call_sentiments.json');

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}}/v2/call_sentiments.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/call_sentiments.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/call_sentiments.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/call_sentiments.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/call_sentiments.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/call_sentiments.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/call_sentiments.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/call_sentiments.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/call_sentiments.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/call_sentiments.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/call_sentiments.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/call_sentiments.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/call_sentiments.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/call_sentiments.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/call_sentiments.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/call_sentiments.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/call_sentiments.json

http GET {{baseUrl}}/v2/call_sentiments.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/call_sentiments.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/call_sentiments.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List caller ids

{{baseUrl}}/v2/phone_numbers/caller_ids.json

QUERY PARAMS

phone_number

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/phone_numbers/caller_ids.json" {:query-params {:phone_number ""}})

require "http/client"

url = "{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/phone_numbers/caller_ids.json?phone_number= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number="))
    .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}}/v2/phone_numbers/caller_ids.json?phone_number=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number=")
  .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}}/v2/phone_numbers/caller_ids.json?phone_number=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/phone_numbers/caller_ids.json',
  params: {phone_number: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/phone_numbers/caller_ids.json?phone_number=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/phone_numbers/caller_ids.json',
  qs: {phone_number: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/phone_numbers/caller_ids.json');

req.query({
  phone_number: ''
});

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}}/v2/phone_numbers/caller_ids.json',
  params: {phone_number: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/phone_numbers/caller_ids.json');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'phone_number' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/phone_numbers/caller_ids.json');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'phone_number' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/phone_numbers/caller_ids.json?phone_number=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/phone_numbers/caller_ids.json"

querystring = {"phone_number":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/phone_numbers/caller_ids.json"

queryString <- list(phone_number = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/phone_numbers/caller_ids.json') do |req|
  req.params['phone_number'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/phone_numbers/caller_ids.json";

    let querystring = [
        ("phone_number", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number='

http GET '{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/phone_numbers/caller_ids.json?phone_number=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create a call

{{baseUrl}}/v2/activities/calls.json

BODY formUrlEncoded

action_id

crm_params

disposition

duration

linked_call_data_record_ids

notes

person_id

sentiment

user_guid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/activities/calls.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "action_id=&crm_params=&disposition=&duration=&linked_call_data_record_ids=¬es=&person_id=&sentiment=&to=&user_guid=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/activities/calls.json" {:form-params {:action_id ""
                                                                                   :crm_params ""
                                                                                   :disposition ""
                                                                                   :duration ""
                                                                                   :linked_call_data_record_ids ""
                                                                                   :notes ""
                                                                                   :person_id ""
                                                                                   :sentiment ""
                                                                                   :to ""
                                                                                   :user_guid ""}})

require "http/client"

url = "{{baseUrl}}/v2/activities/calls.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "action_id=&crm_params=&disposition=&duration=&linked_call_data_record_ids=¬es=&person_id=&sentiment=&to=&user_guid="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/activities/calls.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "action_id", "" },
        { "crm_params", "" },
        { "disposition", "" },
        { "duration", "" },
        { "linked_call_data_record_ids", "" },
        { "notes", "" },
        { "person_id", "" },
        { "sentiment", "" },
        { "to", "" },
        { "user_guid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/activities/calls.json");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "action_id=&crm_params=&disposition=&duration=&linked_call_data_record_ids=¬es=&person_id=&sentiment=&to=&user_guid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/activities/calls.json"

	payload := strings.NewReader("action_id=&crm_params=&disposition=&duration=&linked_call_data_record_ids=¬es=&person_id=&sentiment=&to=&user_guid=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/activities/calls.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 118

action_id=&crm_params=&disposition=&duration=&linked_call_data_record_ids=¬es=&person_id=&sentiment=&to=&user_guid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/activities/calls.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("action_id=&crm_params=&disposition=&duration=&linked_call_data_record_ids=¬es=&person_id=&sentiment=&to=&user_guid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/activities/calls.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("action_id=&crm_params=&disposition=&duration=&linked_call_data_record_ids=¬es=&person_id=&sentiment=&to=&user_guid="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "action_id=&crm_params=&disposition=&duration=&linked_call_data_record_ids=¬es=&person_id=&sentiment=&to=&user_guid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/activities/calls.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/activities/calls.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("action_id=&crm_params=&disposition=&duration=&linked_call_data_record_ids=¬es=&person_id=&sentiment=&to=&user_guid=")
  .asString();

const data = 'action_id=&crm_params=&disposition=&duration=&linked_call_data_record_ids=¬es=&person_id=&sentiment=&to=&user_guid=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/activities/calls.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('action_id', '');
encodedParams.set('crm_params', '');
encodedParams.set('disposition', '');
encodedParams.set('duration', '');
encodedParams.set('linked_call_data_record_ids', '');
encodedParams.set('notes', '');
encodedParams.set('person_id', '');
encodedParams.set('sentiment', '');
encodedParams.set('to', '');
encodedParams.set('user_guid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/activities/calls.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/activities/calls.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    action_id: '',
    crm_params: '',
    disposition: '',
    duration: '',
    linked_call_data_record_ids: '',
    notes: '',
    person_id: '',
    sentiment: '',
    to: '',
    user_guid: ''
  })
};

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}}/v2/activities/calls.json',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    action_id: '',
    crm_params: '',
    disposition: '',
    duration: '',
    linked_call_data_record_ids: '',
    notes: '',
    person_id: '',
    sentiment: '',
    to: '',
    user_guid: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "action_id=&crm_params=&disposition=&duration=&linked_call_data_record_ids=¬es=&person_id=&sentiment=&to=&user_guid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/activities/calls.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/activities/calls.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({
  action_id: '',
  crm_params: '',
  disposition: '',
  duration: '',
  linked_call_data_record_ids: '',
  notes: '',
  person_id: '',
  sentiment: '',
  to: '',
  user_guid: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/activities/calls.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    action_id: '',
    crm_params: '',
    disposition: '',
    duration: '',
    linked_call_data_record_ids: '',
    notes: '',
    person_id: '',
    sentiment: '',
    to: '',
    user_guid: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/activities/calls.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  action_id: '',
  crm_params: '',
  disposition: '',
  duration: '',
  linked_call_data_record_ids: '',
  notes: '',
  person_id: '',
  sentiment: '',
  to: '',
  user_guid: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('action_id', '');
encodedParams.set('crm_params', '');
encodedParams.set('disposition', '');
encodedParams.set('duration', '');
encodedParams.set('linked_call_data_record_ids', '');
encodedParams.set('notes', '');
encodedParams.set('person_id', '');
encodedParams.set('sentiment', '');
encodedParams.set('to', '');
encodedParams.set('user_guid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/activities/calls.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('action_id', '');
encodedParams.set('crm_params', '');
encodedParams.set('disposition', '');
encodedParams.set('duration', '');
encodedParams.set('linked_call_data_record_ids', '');
encodedParams.set('notes', '');
encodedParams.set('person_id', '');
encodedParams.set('sentiment', '');
encodedParams.set('to', '');
encodedParams.set('user_guid', '');

const url = '{{baseUrl}}/v2/activities/calls.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"action_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&crm_params=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&disposition=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&duration=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&linked_call_data_record_ids=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"¬es=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&person_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&sentiment=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&to=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&user_guid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/activities/calls.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/activities/calls.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "action_id=&crm_params=&disposition=&duration=&linked_call_data_record_ids=¬es=&person_id=&sentiment=&to=&user_guid=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/activities/calls.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "action_id=&crm_params=&disposition=&duration=&linked_call_data_record_ids=¬es=&person_id=&sentiment=&to=&user_guid=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/activities/calls.json', [
  'form_params' => [
    'action_id' => '',
    'crm_params' => '',
    'disposition' => '',
    'duration' => '',
    'linked_call_data_record_ids' => '',
    'notes' => '',
    'person_id' => '',
    'sentiment' => '',
    'to' => '',
    'user_guid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/activities/calls.json');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'action_id' => '',
  'crm_params' => '',
  'disposition' => '',
  'duration' => '',
  'linked_call_data_record_ids' => '',
  'notes' => '',
  'person_id' => '',
  'sentiment' => '',
  'to' => '',
  'user_guid' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'action_id' => '',
  'crm_params' => '',
  'disposition' => '',
  'duration' => '',
  'linked_call_data_record_ids' => '',
  'notes' => '',
  'person_id' => '',
  'sentiment' => '',
  'to' => '',
  'user_guid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/activities/calls.json');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/activities/calls.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'action_id=&crm_params=&disposition=&duration=&linked_call_data_record_ids=¬es=&person_id=&sentiment=&to=&user_guid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/activities/calls.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'action_id=&crm_params=&disposition=&duration=&linked_call_data_record_ids=¬es=&person_id=&sentiment=&to=&user_guid='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "action_id=&crm_params=&disposition=&duration=&linked_call_data_record_ids=¬es=&person_id=&sentiment=&to=&user_guid="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/activities/calls.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/activities/calls.json"

payload = {
    "action_id": "",
    "crm_params": "",
    "disposition": "",
    "duration": "",
    "linked_call_data_record_ids": "",
    "notes": "",
    "person_id": "",
    "sentiment": "",
    "to": "",
    "user_guid": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/activities/calls.json"

payload <- "action_id=&crm_params=&disposition=&duration=&linked_call_data_record_ids=¬es=&person_id=&sentiment=&to=&user_guid="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/activities/calls.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "action_id=&crm_params=&disposition=&duration=&linked_call_data_record_ids=¬es=&person_id=&sentiment=&to=&user_guid="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :action_id => "",
  :crm_params => "",
  :disposition => "",
  :duration => "",
  :linked_call_data_record_ids => "",
  :notes => "",
  :person_id => "",
  :sentiment => "",
  :to => "",
  :user_guid => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/activities/calls.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/activities/calls.json";

    let payload = json!({
        "action_id": "",
        "crm_params": "",
        "disposition": "",
        "duration": "",
        "linked_call_data_record_ids": "",
        "notes": "",
        "person_id": "",
        "sentiment": "",
        "to": "",
        "user_guid": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/activities/calls.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data action_id= \
  --data crm_params= \
  --data disposition= \
  --data duration= \
  --data linked_call_data_record_ids= \
  --data notes= \
  --data person_id= \
  --data sentiment= \
  --data to= \
  --data user_guid=

http --form POST {{baseUrl}}/v2/activities/calls.json \
  content-type:application/x-www-form-urlencoded \
  action_id='' \
  crm_params='' \
  disposition='' \
  duration='' \
  linked_call_data_record_ids='' \
  notes='' \
  person_id='' \
  sentiment='' \
  to='' \
  user_guid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'action_id=&crm_params=&disposition=&duration=&linked_call_data_record_ids=¬es=&person_id=&sentiment=&to=&user_guid=' \
  --output-document \
  - {{baseUrl}}/v2/activities/calls.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "action_id=".data(using: String.Encoding.utf8)!)
postData.append("&crm_params=".data(using: String.Encoding.utf8)!)
postData.append("&disposition=".data(using: String.Encoding.utf8)!)
postData.append("&duration=".data(using: String.Encoding.utf8)!)
postData.append("&linked_call_data_record_ids=".data(using: String.Encoding.utf8)!)
postData.append("¬es=".data(using: String.Encoding.utf8)!)
postData.append("&person_id=".data(using: String.Encoding.utf8)!)
postData.append("&sentiment=".data(using: String.Encoding.utf8)!)
postData.append("&to=".data(using: String.Encoding.utf8)!)
postData.append("&user_guid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/activities/calls.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch a call

{{baseUrl}}/v2/activities/calls/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/activities/calls/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/activities/calls/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/activities/calls/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/activities/calls/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/activities/calls/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/activities/calls/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/activities/calls/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/activities/calls/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/activities/calls/:id.json"))
    .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}}/v2/activities/calls/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/activities/calls/:id.json")
  .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}}/v2/activities/calls/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/activities/calls/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/activities/calls/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/activities/calls/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/activities/calls/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/activities/calls/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/activities/calls/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/activities/calls/:id.json');

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}}/v2/activities/calls/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/activities/calls/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/activities/calls/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/activities/calls/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/activities/calls/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/activities/calls/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/activities/calls/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/activities/calls/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/activities/calls/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/activities/calls/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/activities/calls/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/activities/calls/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/activities/calls/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/activities/calls/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/activities/calls/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/activities/calls/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/activities/calls/:id.json

http GET {{baseUrl}}/v2/activities/calls/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/activities/calls/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/activities/calls/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List calls

{{baseUrl}}/v2/activities/calls.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/activities/calls.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/activities/calls.json")

require "http/client"

url = "{{baseUrl}}/v2/activities/calls.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/activities/calls.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/activities/calls.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/activities/calls.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/activities/calls.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/activities/calls.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/activities/calls.json"))
    .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}}/v2/activities/calls.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/activities/calls.json")
  .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}}/v2/activities/calls.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/activities/calls.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/activities/calls.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/activities/calls.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/activities/calls.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/activities/calls.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/activities/calls.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/activities/calls.json');

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}}/v2/activities/calls.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/activities/calls.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/activities/calls.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/activities/calls.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/activities/calls.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/activities/calls.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/activities/calls.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/activities/calls.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/activities/calls.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/activities/calls.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/activities/calls.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/activities/calls.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/activities/calls.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/activities/calls.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/activities/calls.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/activities/calls.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/activities/calls.json

http GET {{baseUrl}}/v2/activities/calls.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/activities/calls.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/activities/calls.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create Conversations Call

{{baseUrl}}/v2/conversations/calls

BODY formUrlEncoded

call_created_at

direction

duration

from

recording

user_guid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/conversations/calls");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "call_created_at=&direction=&duration=&from=&recording=&to=&user_guid=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/conversations/calls" {:form-params {:call_created_at ""
                                                                                 :direction ""
                                                                                 :duration ""
                                                                                 :from ""
                                                                                 :recording ""
                                                                                 :to ""
                                                                                 :user_guid ""}})

require "http/client"

url = "{{baseUrl}}/v2/conversations/calls"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "call_created_at=&direction=&duration=&from=&recording=&to=&user_guid="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/conversations/calls"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "call_created_at", "" },
        { "direction", "" },
        { "duration", "" },
        { "from", "" },
        { "recording", "" },
        { "to", "" },
        { "user_guid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/conversations/calls");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "call_created_at=&direction=&duration=&from=&recording=&to=&user_guid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/conversations/calls"

	payload := strings.NewReader("call_created_at=&direction=&duration=&from=&recording=&to=&user_guid=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/conversations/calls HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 69

call_created_at=&direction=&duration=&from=&recording=&to=&user_guid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/conversations/calls")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("call_created_at=&direction=&duration=&from=&recording=&to=&user_guid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/conversations/calls"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("call_created_at=&direction=&duration=&from=&recording=&to=&user_guid="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "call_created_at=&direction=&duration=&from=&recording=&to=&user_guid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/conversations/calls")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/conversations/calls")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("call_created_at=&direction=&duration=&from=&recording=&to=&user_guid=")
  .asString();

const data = 'call_created_at=&direction=&duration=&from=&recording=&to=&user_guid=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/conversations/calls');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('call_created_at', '');
encodedParams.set('direction', '');
encodedParams.set('duration', '');
encodedParams.set('from', '');
encodedParams.set('recording', '');
encodedParams.set('to', '');
encodedParams.set('user_guid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/conversations/calls',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/conversations/calls';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    call_created_at: '',
    direction: '',
    duration: '',
    from: '',
    recording: '',
    to: '',
    user_guid: ''
  })
};

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}}/v2/conversations/calls',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    call_created_at: '',
    direction: '',
    duration: '',
    from: '',
    recording: '',
    to: '',
    user_guid: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "call_created_at=&direction=&duration=&from=&recording=&to=&user_guid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/conversations/calls")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/conversations/calls',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({
  call_created_at: '',
  direction: '',
  duration: '',
  from: '',
  recording: '',
  to: '',
  user_guid: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/conversations/calls',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    call_created_at: '',
    direction: '',
    duration: '',
    from: '',
    recording: '',
    to: '',
    user_guid: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/conversations/calls');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  call_created_at: '',
  direction: '',
  duration: '',
  from: '',
  recording: '',
  to: '',
  user_guid: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('call_created_at', '');
encodedParams.set('direction', '');
encodedParams.set('duration', '');
encodedParams.set('from', '');
encodedParams.set('recording', '');
encodedParams.set('to', '');
encodedParams.set('user_guid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/conversations/calls',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('call_created_at', '');
encodedParams.set('direction', '');
encodedParams.set('duration', '');
encodedParams.set('from', '');
encodedParams.set('recording', '');
encodedParams.set('to', '');
encodedParams.set('user_guid', '');

const url = '{{baseUrl}}/v2/conversations/calls';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"call_created_at=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&direction=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&duration=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&from=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&recording=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&to=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&user_guid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/conversations/calls"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/conversations/calls" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "call_created_at=&direction=&duration=&from=&recording=&to=&user_guid=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/conversations/calls",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "call_created_at=&direction=&duration=&from=&recording=&to=&user_guid=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/conversations/calls', [
  'form_params' => [
    'call_created_at' => '',
    'direction' => '',
    'duration' => '',
    'from' => '',
    'recording' => '',
    'to' => '',
    'user_guid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/conversations/calls');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'call_created_at' => '',
  'direction' => '',
  'duration' => '',
  'from' => '',
  'recording' => '',
  'to' => '',
  'user_guid' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'call_created_at' => '',
  'direction' => '',
  'duration' => '',
  'from' => '',
  'recording' => '',
  'to' => '',
  'user_guid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/conversations/calls');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/conversations/calls' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'call_created_at=&direction=&duration=&from=&recording=&to=&user_guid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/conversations/calls' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'call_created_at=&direction=&duration=&from=&recording=&to=&user_guid='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "call_created_at=&direction=&duration=&from=&recording=&to=&user_guid="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/conversations/calls", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/conversations/calls"

payload = {
    "call_created_at": "",
    "direction": "",
    "duration": "",
    "from": "",
    "recording": "",
    "to": "",
    "user_guid": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/conversations/calls"

payload <- "call_created_at=&direction=&duration=&from=&recording=&to=&user_guid="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/conversations/calls")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "call_created_at=&direction=&duration=&from=&recording=&to=&user_guid="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :call_created_at => "",
  :direction => "",
  :duration => "",
  :from => "",
  :recording => "",
  :to => "",
  :user_guid => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/conversations/calls') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/conversations/calls";

    let payload = json!({
        "call_created_at": "",
        "direction": "",
        "duration": "",
        "from": "",
        "recording": "",
        "to": "",
        "user_guid": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/conversations/calls \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data call_created_at= \
  --data direction= \
  --data duration= \
  --data from= \
  --data recording= \
  --data to= \
  --data user_guid=

http --form POST {{baseUrl}}/v2/conversations/calls \
  content-type:application/x-www-form-urlencoded \
  call_created_at='' \
  direction='' \
  duration='' \
  from='' \
  recording='' \
  to='' \
  user_guid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'call_created_at=&direction=&duration=&from=&recording=&to=&user_guid=' \
  --output-document \
  - {{baseUrl}}/v2/conversations/calls

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "call_created_at=".data(using: String.Encoding.utf8)!)
postData.append("&direction=".data(using: String.Encoding.utf8)!)
postData.append("&duration=".data(using: String.Encoding.utf8)!)
postData.append("&from=".data(using: String.Encoding.utf8)!)
postData.append("&recording=".data(using: String.Encoding.utf8)!)
postData.append("&to=".data(using: String.Encoding.utf8)!)
postData.append("&user_guid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/conversations/calls")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch a crm activity

{{baseUrl}}/v2/crm_activities/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/crm_activities/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/crm_activities/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/crm_activities/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/crm_activities/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/crm_activities/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/crm_activities/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/crm_activities/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/crm_activities/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/crm_activities/:id.json"))
    .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}}/v2/crm_activities/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/crm_activities/:id.json")
  .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}}/v2/crm_activities/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/crm_activities/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/crm_activities/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/crm_activities/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/crm_activities/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/crm_activities/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/crm_activities/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/crm_activities/:id.json');

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}}/v2/crm_activities/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/crm_activities/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/crm_activities/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/crm_activities/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/crm_activities/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/crm_activities/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/crm_activities/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/crm_activities/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/crm_activities/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/crm_activities/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/crm_activities/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/crm_activities/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/crm_activities/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/crm_activities/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/crm_activities/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/crm_activities/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/crm_activities/:id.json

http GET {{baseUrl}}/v2/crm_activities/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/crm_activities/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/crm_activities/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List crm activities

{{baseUrl}}/v2/crm_activities.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/crm_activities.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/crm_activities.json")

require "http/client"

url = "{{baseUrl}}/v2/crm_activities.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/crm_activities.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/crm_activities.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/crm_activities.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/crm_activities.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/crm_activities.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/crm_activities.json"))
    .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}}/v2/crm_activities.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/crm_activities.json")
  .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}}/v2/crm_activities.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/crm_activities.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/crm_activities.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/crm_activities.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/crm_activities.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/crm_activities.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/crm_activities.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/crm_activities.json');

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}}/v2/crm_activities.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/crm_activities.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/crm_activities.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/crm_activities.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/crm_activities.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/crm_activities.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/crm_activities.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/crm_activities.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/crm_activities.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/crm_activities.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/crm_activities.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/crm_activities.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/crm_activities.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/crm_activities.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/crm_activities.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/crm_activities.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/crm_activities.json

http GET {{baseUrl}}/v2/crm_activities.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/crm_activities.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/crm_activities.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List crm activity fields

{{baseUrl}}/v2/crm_activity_fields.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/crm_activity_fields.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/crm_activity_fields.json")

require "http/client"

url = "{{baseUrl}}/v2/crm_activity_fields.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/crm_activity_fields.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/crm_activity_fields.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/crm_activity_fields.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/crm_activity_fields.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/crm_activity_fields.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/crm_activity_fields.json"))
    .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}}/v2/crm_activity_fields.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/crm_activity_fields.json")
  .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}}/v2/crm_activity_fields.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/crm_activity_fields.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/crm_activity_fields.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/crm_activity_fields.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/crm_activity_fields.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/crm_activity_fields.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/crm_activity_fields.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/crm_activity_fields.json');

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}}/v2/crm_activity_fields.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/crm_activity_fields.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/crm_activity_fields.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/crm_activity_fields.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/crm_activity_fields.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/crm_activity_fields.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/crm_activity_fields.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/crm_activity_fields.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/crm_activity_fields.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/crm_activity_fields.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/crm_activity_fields.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/crm_activity_fields.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/crm_activity_fields.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/crm_activity_fields.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/crm_activity_fields.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/crm_activity_fields.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/crm_activity_fields.json

http GET {{baseUrl}}/v2/crm_activity_fields.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/crm_activity_fields.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/crm_activity_fields.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List crm users

{{baseUrl}}/v2/crm_users.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/crm_users.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/crm_users.json")

require "http/client"

url = "{{baseUrl}}/v2/crm_users.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/crm_users.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/crm_users.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/crm_users.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/crm_users.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/crm_users.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/crm_users.json"))
    .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}}/v2/crm_users.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/crm_users.json")
  .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}}/v2/crm_users.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/crm_users.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/crm_users.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/crm_users.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/crm_users.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/crm_users.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/crm_users.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/crm_users.json');

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}}/v2/crm_users.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/crm_users.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/crm_users.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/crm_users.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/crm_users.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/crm_users.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/crm_users.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/crm_users.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/crm_users.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/crm_users.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/crm_users.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/crm_users.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/crm_users.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/crm_users.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/crm_users.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/crm_users.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/crm_users.json

http GET {{baseUrl}}/v2/crm_users.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/crm_users.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/crm_users.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create a custom field

{{baseUrl}}/v2/custom_fields.json

BODY formUrlEncoded

field_type

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/custom_fields.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "field_type=&name=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/custom_fields.json" {:form-params {:field_type ""
                                                                                :name ""}})

require "http/client"

url = "{{baseUrl}}/v2/custom_fields.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "field_type=&name="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/custom_fields.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "field_type", "" },
        { "name", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/custom_fields.json");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "field_type=&name=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/custom_fields.json"

	payload := strings.NewReader("field_type=&name=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/custom_fields.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 17

field_type=&name=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/custom_fields.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("field_type=&name=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/custom_fields.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("field_type=&name="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "field_type=&name=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/custom_fields.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/custom_fields.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("field_type=&name=")
  .asString();

const data = 'field_type=&name=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/custom_fields.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('field_type', '');
encodedParams.set('name', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/custom_fields.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/custom_fields.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({field_type: '', name: ''})
};

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}}/v2/custom_fields.json',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    field_type: '',
    name: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "field_type=&name=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/custom_fields.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/custom_fields.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({field_type: '', name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/custom_fields.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {field_type: '', name: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/custom_fields.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  field_type: '',
  name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('field_type', '');
encodedParams.set('name', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/custom_fields.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('field_type', '');
encodedParams.set('name', '');

const url = '{{baseUrl}}/v2/custom_fields.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"field_type=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&name=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/custom_fields.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/custom_fields.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "field_type=&name=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/custom_fields.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "field_type=&name=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/custom_fields.json', [
  'form_params' => [
    'field_type' => '',
    'name' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/custom_fields.json');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'field_type' => '',
  'name' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'field_type' => '',
  'name' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/custom_fields.json');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/custom_fields.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'field_type=&name='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/custom_fields.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'field_type=&name='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "field_type=&name="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/custom_fields.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/custom_fields.json"

payload = {
    "field_type": "",
    "name": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/custom_fields.json"

payload <- "field_type=&name="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/custom_fields.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "field_type=&name="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :field_type => "",
  :name => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/custom_fields.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/custom_fields.json";

    let payload = json!({
        "field_type": "",
        "name": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/custom_fields.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data field_type= \
  --data name=

http --form POST {{baseUrl}}/v2/custom_fields.json \
  content-type:application/x-www-form-urlencoded \
  field_type='' \
  name=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'field_type=&name=' \
  --output-document \
  - {{baseUrl}}/v2/custom_fields.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "field_type=".data(using: String.Encoding.utf8)!)
postData.append("&name=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/custom_fields.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Delete a custom field

{{baseUrl}}/v2/custom_fields/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/custom_fields/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v2/custom_fields/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/custom_fields/:id.json"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v2/custom_fields/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/custom_fields/:id.json");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/custom_fields/:id.json"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v2/custom_fields/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/custom_fields/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/custom_fields/:id.json"))
    .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}}/v2/custom_fields/:id.json")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v2/custom_fields/:id.json")
  .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}}/v2/custom_fields/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v2/custom_fields/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/custom_fields/:id.json';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/custom_fields/:id.json',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/custom_fields/:id.json")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/custom_fields/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/v2/custom_fields/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/custom_fields/:id.json');

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}}/v2/custom_fields/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/custom_fields/:id.json';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/custom_fields/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/custom_fields/:id.json" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/custom_fields/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v2/custom_fields/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/custom_fields/:id.json');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/custom_fields/:id.json');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/custom_fields/:id.json' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/custom_fields/:id.json' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v2/custom_fields/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/custom_fields/:id.json"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/custom_fields/:id.json"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/custom_fields/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v2/custom_fields/:id.json') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/custom_fields/:id.json";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v2/custom_fields/:id.json

http DELETE {{baseUrl}}/v2/custom_fields/:id.json

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/custom_fields/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/custom_fields/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch a custom field

{{baseUrl}}/v2/custom_fields/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/custom_fields/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/custom_fields/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/custom_fields/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/custom_fields/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/custom_fields/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/custom_fields/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/custom_fields/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/custom_fields/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/custom_fields/:id.json"))
    .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}}/v2/custom_fields/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/custom_fields/:id.json")
  .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}}/v2/custom_fields/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/custom_fields/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/custom_fields/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/custom_fields/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/custom_fields/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/custom_fields/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/custom_fields/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/custom_fields/:id.json');

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}}/v2/custom_fields/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/custom_fields/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/custom_fields/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/custom_fields/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/custom_fields/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/custom_fields/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/custom_fields/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/custom_fields/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/custom_fields/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/custom_fields/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/custom_fields/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/custom_fields/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/custom_fields/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/custom_fields/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/custom_fields/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/custom_fields/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/custom_fields/:id.json

http GET {{baseUrl}}/v2/custom_fields/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/custom_fields/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/custom_fields/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List custom fields

{{baseUrl}}/v2/custom_fields.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/custom_fields.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/custom_fields.json")

require "http/client"

url = "{{baseUrl}}/v2/custom_fields.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/custom_fields.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/custom_fields.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/custom_fields.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/custom_fields.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/custom_fields.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/custom_fields.json"))
    .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}}/v2/custom_fields.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/custom_fields.json")
  .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}}/v2/custom_fields.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/custom_fields.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/custom_fields.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/custom_fields.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/custom_fields.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/custom_fields.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/custom_fields.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/custom_fields.json');

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}}/v2/custom_fields.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/custom_fields.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/custom_fields.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/custom_fields.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/custom_fields.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/custom_fields.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/custom_fields.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/custom_fields.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/custom_fields.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/custom_fields.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/custom_fields.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/custom_fields.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/custom_fields.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/custom_fields.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/custom_fields.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/custom_fields.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/custom_fields.json

http GET {{baseUrl}}/v2/custom_fields.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/custom_fields.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/custom_fields.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT Update a custom field

{{baseUrl}}/v2/custom_fields/:id.json

QUERY PARAMS

BODY formUrlEncoded

field_type

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/custom_fields/:id.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "field_type=&name=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v2/custom_fields/:id.json" {:form-params {:field_type ""
                                                                                   :name ""}})

require "http/client"

url = "{{baseUrl}}/v2/custom_fields/:id.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "field_type=&name="

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v2/custom_fields/:id.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "field_type", "" },
        { "name", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/custom_fields/:id.json");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "field_type=&name=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/custom_fields/:id.json"

	payload := strings.NewReader("field_type=&name=")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/v2/custom_fields/:id.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 17

field_type=&name=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v2/custom_fields/:id.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("field_type=&name=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/custom_fields/:id.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("PUT", HttpRequest.BodyPublishers.ofString("field_type=&name="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "field_type=&name=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/custom_fields/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v2/custom_fields/:id.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("field_type=&name=")
  .asString();

const data = 'field_type=&name=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v2/custom_fields/:id.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('field_type', '');
encodedParams.set('name', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/custom_fields/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/custom_fields/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({field_type: '', name: ''})
};

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}}/v2/custom_fields/:id.json',
  method: 'PUT',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    field_type: '',
    name: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "field_type=&name=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/custom_fields/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/custom_fields/:id.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({field_type: '', name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/custom_fields/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {field_type: '', name: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/v2/custom_fields/:id.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  field_type: '',
  name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('field_type', '');
encodedParams.set('name', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/custom_fields/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('field_type', '');
encodedParams.set('name', '');

const url = '{{baseUrl}}/v2/custom_fields/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"field_type=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&name=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/custom_fields/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/custom_fields/:id.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "field_type=&name=" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/custom_fields/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => "field_type=&name=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/v2/custom_fields/:id.json', [
  'form_params' => [
    'field_type' => '',
    'name' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/custom_fields/:id.json');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'field_type' => '',
  'name' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'field_type' => '',
  'name' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/custom_fields/:id.json');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/custom_fields/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'field_type=&name='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/custom_fields/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'field_type=&name='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "field_type=&name="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PUT", "/baseUrl/v2/custom_fields/:id.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/custom_fields/:id.json"

payload = {
    "field_type": "",
    "name": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.put(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/custom_fields/:id.json"

payload <- "field_type=&name="

encode <- "form"

response <- VERB("PUT", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/custom_fields/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "field_type=&name="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :field_type => "",
  :name => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.put('/baseUrl/v2/custom_fields/:id.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/custom_fields/:id.json";

    let payload = json!({
        "field_type": "",
        "name": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/v2/custom_fields/:id.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data field_type= \
  --data name=

http --form PUT {{baseUrl}}/v2/custom_fields/:id.json \
  content-type:application/x-www-form-urlencoded \
  field_type='' \
  name=''

wget --quiet \
  --method PUT \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'field_type=&name=' \
  --output-document \
  - {{baseUrl}}/v2/custom_fields/:id.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "field_type=".data(using: String.Encoding.utf8)!)
postData.append("&name=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/custom_fields/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List email template attachments

{{baseUrl}}/v2/email_template_attachments.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/email_template_attachments.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/email_template_attachments.json")

require "http/client"

url = "{{baseUrl}}/v2/email_template_attachments.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/email_template_attachments.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/email_template_attachments.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/email_template_attachments.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/email_template_attachments.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/email_template_attachments.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/email_template_attachments.json"))
    .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}}/v2/email_template_attachments.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/email_template_attachments.json")
  .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}}/v2/email_template_attachments.json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/email_template_attachments.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/email_template_attachments.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/email_template_attachments.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/email_template_attachments.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/email_template_attachments.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/email_template_attachments.json'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/email_template_attachments.json');

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}}/v2/email_template_attachments.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/email_template_attachments.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/email_template_attachments.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/email_template_attachments.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/email_template_attachments.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/email_template_attachments.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/email_template_attachments.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/email_template_attachments.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/email_template_attachments.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/email_template_attachments.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/email_template_attachments.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/email_template_attachments.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/email_template_attachments.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/email_template_attachments.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/email_template_attachments.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/email_template_attachments.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/email_template_attachments.json

http GET {{baseUrl}}/v2/email_template_attachments.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/email_template_attachments.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/email_template_attachments.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch an email template

{{baseUrl}}/v2/email_templates/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/email_templates/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/email_templates/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/email_templates/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/email_templates/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/email_templates/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/email_templates/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/email_templates/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/email_templates/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/email_templates/:id.json"))
    .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}}/v2/email_templates/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/email_templates/:id.json")
  .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}}/v2/email_templates/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/email_templates/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/email_templates/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/email_templates/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/email_templates/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/email_templates/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/email_templates/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/email_templates/:id.json');

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}}/v2/email_templates/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/email_templates/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/email_templates/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/email_templates/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/email_templates/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/email_templates/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/email_templates/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/email_templates/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/email_templates/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/email_templates/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/email_templates/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/email_templates/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/email_templates/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/email_templates/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/email_templates/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/email_templates/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/email_templates/:id.json

http GET {{baseUrl}}/v2/email_templates/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/email_templates/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/email_templates/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List email templates

{{baseUrl}}/v2/email_templates.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/email_templates.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/email_templates.json")

require "http/client"

url = "{{baseUrl}}/v2/email_templates.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/email_templates.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/email_templates.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/email_templates.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/email_templates.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/email_templates.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/email_templates.json"))
    .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}}/v2/email_templates.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/email_templates.json")
  .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}}/v2/email_templates.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/email_templates.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/email_templates.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/email_templates.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/email_templates.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/email_templates.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/email_templates.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/email_templates.json');

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}}/v2/email_templates.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/email_templates.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/email_templates.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/email_templates.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/email_templates.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/email_templates.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/email_templates.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/email_templates.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/email_templates.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/email_templates.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/email_templates.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/email_templates.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/email_templates.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/email_templates.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/email_templates.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/email_templates.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/email_templates.json

http GET {{baseUrl}}/v2/email_templates.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/email_templates.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/email_templates.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch an email

{{baseUrl}}/v2/activities/emails/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/activities/emails/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/activities/emails/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/activities/emails/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/activities/emails/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/activities/emails/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/activities/emails/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/activities/emails/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/activities/emails/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/activities/emails/:id.json"))
    .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}}/v2/activities/emails/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/activities/emails/:id.json")
  .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}}/v2/activities/emails/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/activities/emails/:id.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/activities/emails/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/activities/emails/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/activities/emails/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/activities/emails/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/activities/emails/:id.json'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/activities/emails/:id.json');

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}}/v2/activities/emails/:id.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/activities/emails/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/activities/emails/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/activities/emails/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/activities/emails/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/activities/emails/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/activities/emails/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/activities/emails/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/activities/emails/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/activities/emails/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/activities/emails/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/activities/emails/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/activities/emails/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/activities/emails/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/activities/emails/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/activities/emails/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/activities/emails/:id.json

http GET {{baseUrl}}/v2/activities/emails/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/activities/emails/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/activities/emails/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List emails

{{baseUrl}}/v2/activities/emails.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/activities/emails.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/activities/emails.json")

require "http/client"

url = "{{baseUrl}}/v2/activities/emails.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/activities/emails.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/activities/emails.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/activities/emails.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/activities/emails.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/activities/emails.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/activities/emails.json"))
    .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}}/v2/activities/emails.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/activities/emails.json")
  .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}}/v2/activities/emails.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/activities/emails.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/activities/emails.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/activities/emails.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/activities/emails.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/activities/emails.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/activities/emails.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/activities/emails.json');

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}}/v2/activities/emails.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/activities/emails.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/activities/emails.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/activities/emails.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/activities/emails.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/activities/emails.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/activities/emails.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/activities/emails.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/activities/emails.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/activities/emails.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/activities/emails.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/activities/emails.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/activities/emails.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/activities/emails.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/activities/emails.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/activities/emails.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/activities/emails.json

http GET {{baseUrl}}/v2/activities/emails.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/activities/emails.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/activities/emails.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create an External Email

{{baseUrl}}/v2/external_emails.json

BODY formUrlEncoded

mailbox

raw

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/external_emails.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "mailbox=&raw=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/external_emails.json" {:form-params {:mailbox ""
                                                                                  :raw ""}})

require "http/client"

url = "{{baseUrl}}/v2/external_emails.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "mailbox=&raw="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/external_emails.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "mailbox", "" },
        { "raw", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/external_emails.json");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "mailbox=&raw=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/external_emails.json"

	payload := strings.NewReader("mailbox=&raw=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/external_emails.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 13

mailbox=&raw=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/external_emails.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("mailbox=&raw=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/external_emails.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("mailbox=&raw="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "mailbox=&raw=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/external_emails.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/external_emails.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("mailbox=&raw=")
  .asString();

const data = 'mailbox=&raw=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/external_emails.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('mailbox', '');
encodedParams.set('raw', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/external_emails.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/external_emails.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({mailbox: '', raw: ''})
};

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}}/v2/external_emails.json',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    mailbox: '',
    raw: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "mailbox=&raw=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/external_emails.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/external_emails.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({mailbox: '', raw: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/external_emails.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {mailbox: '', raw: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/external_emails.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  mailbox: '',
  raw: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('mailbox', '');
encodedParams.set('raw', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/external_emails.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('mailbox', '');
encodedParams.set('raw', '');

const url = '{{baseUrl}}/v2/external_emails.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"mailbox=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&raw=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/external_emails.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/external_emails.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "mailbox=&raw=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/external_emails.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "mailbox=&raw=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/external_emails.json', [
  'form_params' => [
    'mailbox' => '',
    'raw' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/external_emails.json');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'mailbox' => '',
  'raw' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'mailbox' => '',
  'raw' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/external_emails.json');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/external_emails.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'mailbox=&raw='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/external_emails.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'mailbox=&raw='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "mailbox=&raw="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/external_emails.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/external_emails.json"

payload = {
    "mailbox": "",
    "raw": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/external_emails.json"

payload <- "mailbox=&raw="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/external_emails.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "mailbox=&raw="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :mailbox => "",
  :raw => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/external_emails.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/external_emails.json";

    let payload = json!({
        "mailbox": "",
        "raw": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/external_emails.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data mailbox= \
  --data raw=

http --form POST {{baseUrl}}/v2/external_emails.json \
  content-type:application/x-www-form-urlencoded \
  mailbox='' \
  raw=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'mailbox=&raw=' \
  --output-document \
  - {{baseUrl}}/v2/external_emails.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "mailbox=".data(using: String.Encoding.utf8)!)
postData.append("&raw=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/external_emails.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch a group

{{baseUrl}}/v2/groups/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/groups/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/groups/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/groups/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/groups/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/groups/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/groups/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/groups/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/groups/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/groups/:id.json"))
    .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}}/v2/groups/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/groups/:id.json")
  .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}}/v2/groups/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/groups/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/groups/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/groups/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/groups/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/groups/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/groups/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/groups/:id.json');

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}}/v2/groups/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/groups/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/groups/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/groups/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/groups/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/groups/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/groups/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/groups/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/groups/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/groups/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/groups/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/groups/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/groups/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/groups/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/groups/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/groups/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/groups/:id.json

http GET {{baseUrl}}/v2/groups/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/groups/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/groups/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List groups

{{baseUrl}}/v2/groups.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/groups.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/groups.json")

require "http/client"

url = "{{baseUrl}}/v2/groups.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/groups.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/groups.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/groups.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/groups.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/groups.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/groups.json"))
    .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}}/v2/groups.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/groups.json")
  .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}}/v2/groups.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/groups.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/groups.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/groups.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/groups.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/groups.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/groups.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/groups.json');

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}}/v2/groups.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/groups.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/groups.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/groups.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/groups.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/groups.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/groups.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/groups.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/groups.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/groups.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/groups.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/groups.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/groups.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/groups.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/groups.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/groups.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/groups.json

http GET {{baseUrl}}/v2/groups.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/groups.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/groups.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create an import

{{baseUrl}}/v2/imports.json

BODY formUrlEncoded

name

user_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/imports.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "name=&user_id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/imports.json" {:form-params {:name ""
                                                                          :user_id ""}})

require "http/client"

url = "{{baseUrl}}/v2/imports.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "name=&user_id="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/imports.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "name", "" },
        { "user_id", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/imports.json");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "name=&user_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/imports.json"

	payload := strings.NewReader("name=&user_id=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/imports.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 14

name=&user_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/imports.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("name=&user_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/imports.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("name=&user_id="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "name=&user_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/imports.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/imports.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("name=&user_id=")
  .asString();

const data = 'name=&user_id=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/imports.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');
encodedParams.set('user_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/imports.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/imports.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({name: '', user_id: ''})
};

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}}/v2/imports.json',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    name: '',
    user_id: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "name=&user_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/imports.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/imports.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({name: '', user_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/imports.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {name: '', user_id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/imports.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  name: '',
  user_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');
encodedParams.set('user_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/imports.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');
encodedParams.set('user_id', '');

const url = '{{baseUrl}}/v2/imports.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&user_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/imports.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/imports.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "name=&user_id=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/imports.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "name=&user_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/imports.json', [
  'form_params' => [
    'name' => '',
    'user_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/imports.json');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'name' => '',
  'user_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'name' => '',
  'user_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/imports.json');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/imports.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'name=&user_id='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/imports.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'name=&user_id='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "name=&user_id="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/imports.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/imports.json"

payload = {
    "name": "",
    "user_id": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/imports.json"

payload <- "name=&user_id="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/imports.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "name=&user_id="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :name => "",
  :user_id => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/imports.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/imports.json";

    let payload = json!({
        "name": "",
        "user_id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/imports.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data name= \
  --data user_id=

http --form POST {{baseUrl}}/v2/imports.json \
  content-type:application/x-www-form-urlencoded \
  name='' \
  user_id=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'name=&user_id=' \
  --output-document \
  - {{baseUrl}}/v2/imports.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "name=".data(using: String.Encoding.utf8)!)
postData.append("&user_id=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/imports.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Delete an import

{{baseUrl}}/v2/imports/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/imports/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v2/imports/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/imports/:id.json"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v2/imports/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/imports/:id.json");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/imports/:id.json"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v2/imports/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/imports/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/imports/:id.json"))
    .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}}/v2/imports/:id.json")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v2/imports/:id.json")
  .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}}/v2/imports/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v2/imports/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/imports/:id.json';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/imports/:id.json',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/imports/:id.json")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/imports/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/v2/imports/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/imports/:id.json');

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}}/v2/imports/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/imports/:id.json';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/imports/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/imports/:id.json" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/imports/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v2/imports/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/imports/:id.json');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/imports/:id.json');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/imports/:id.json' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/imports/:id.json' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v2/imports/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/imports/:id.json"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/imports/:id.json"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/imports/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v2/imports/:id.json') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/imports/:id.json";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v2/imports/:id.json

http DELETE {{baseUrl}}/v2/imports/:id.json

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/imports/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/imports/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch an import

{{baseUrl}}/v2/imports/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/imports/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/imports/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/imports/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/imports/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/imports/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/imports/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/imports/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/imports/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/imports/:id.json"))
    .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}}/v2/imports/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/imports/:id.json")
  .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}}/v2/imports/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/imports/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/imports/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/imports/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/imports/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/imports/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/imports/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/imports/:id.json');

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}}/v2/imports/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/imports/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/imports/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/imports/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/imports/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/imports/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/imports/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/imports/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/imports/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/imports/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/imports/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/imports/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/imports/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/imports/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/imports/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/imports/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/imports/:id.json

http GET {{baseUrl}}/v2/imports/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/imports/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/imports/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List imports

{{baseUrl}}/v2/imports.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/imports.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/imports.json")

require "http/client"

url = "{{baseUrl}}/v2/imports.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/imports.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/imports.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/imports.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/imports.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/imports.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/imports.json"))
    .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}}/v2/imports.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/imports.json")
  .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}}/v2/imports.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/imports.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/imports.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/imports.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/imports.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/imports.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/imports.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/imports.json');

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}}/v2/imports.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/imports.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/imports.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/imports.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/imports.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/imports.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/imports.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/imports.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/imports.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/imports.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/imports.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/imports.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/imports.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/imports.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/imports.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/imports.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/imports.json

http GET {{baseUrl}}/v2/imports.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/imports.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/imports.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT Update an import

{{baseUrl}}/v2/imports/:id.json

QUERY PARAMS

BODY formUrlEncoded

name

user_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/imports/:id.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "name=&user_id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v2/imports/:id.json" {:form-params {:name ""
                                                                             :user_id ""}})

require "http/client"

url = "{{baseUrl}}/v2/imports/:id.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "name=&user_id="

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v2/imports/:id.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "name", "" },
        { "user_id", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/imports/:id.json");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "name=&user_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/imports/:id.json"

	payload := strings.NewReader("name=&user_id=")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/v2/imports/:id.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 14

name=&user_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v2/imports/:id.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("name=&user_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/imports/:id.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("PUT", HttpRequest.BodyPublishers.ofString("name=&user_id="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "name=&user_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/imports/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v2/imports/:id.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("name=&user_id=")
  .asString();

const data = 'name=&user_id=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v2/imports/:id.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');
encodedParams.set('user_id', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/imports/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/imports/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({name: '', user_id: ''})
};

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}}/v2/imports/:id.json',
  method: 'PUT',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    name: '',
    user_id: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "name=&user_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/imports/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/imports/:id.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({name: '', user_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/imports/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {name: '', user_id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/v2/imports/:id.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  name: '',
  user_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');
encodedParams.set('user_id', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/imports/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');
encodedParams.set('user_id', '');

const url = '{{baseUrl}}/v2/imports/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&user_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/imports/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/imports/:id.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "name=&user_id=" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/imports/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => "name=&user_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/v2/imports/:id.json', [
  'form_params' => [
    'name' => '',
    'user_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/imports/:id.json');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'name' => '',
  'user_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'name' => '',
  'user_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/imports/:id.json');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/imports/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'name=&user_id='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/imports/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'name=&user_id='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "name=&user_id="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PUT", "/baseUrl/v2/imports/:id.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/imports/:id.json"

payload = {
    "name": "",
    "user_id": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.put(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/imports/:id.json"

payload <- "name=&user_id="

encode <- "form"

response <- VERB("PUT", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/imports/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "name=&user_id="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :name => "",
  :user_id => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.put('/baseUrl/v2/imports/:id.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/imports/:id.json";

    let payload = json!({
        "name": "",
        "user_id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/v2/imports/:id.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data name= \
  --data user_id=

http --form PUT {{baseUrl}}/v2/imports/:id.json \
  content-type:application/x-www-form-urlencoded \
  name='' \
  user_id=''

wget --quiet \
  --method PUT \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'name=&user_id=' \
  --output-document \
  - {{baseUrl}}/v2/imports/:id.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "name=".data(using: String.Encoding.utf8)!)
postData.append("&user_id=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/imports/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create a live feed item

{{baseUrl}}/v2/third_party_live_feed_items

BODY formUrlEncoded

event_occurred_at

idempotency_key

message

subject_id

subject_type

user_guid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/third_party_live_feed_items");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "event_occurred_at=&idempotency_key=&message=&subject_id=&subject_type=&user_guid=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/third_party_live_feed_items" {:form-params {:event_occurred_at ""
                                                                                         :idempotency_key ""
                                                                                         :message ""
                                                                                         :subject_id ""
                                                                                         :subject_type ""
                                                                                         :user_guid ""}})

require "http/client"

url = "{{baseUrl}}/v2/third_party_live_feed_items"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "event_occurred_at=&idempotency_key=&message=&subject_id=&subject_type=&user_guid="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/third_party_live_feed_items"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "event_occurred_at", "" },
        { "idempotency_key", "" },
        { "message", "" },
        { "subject_id", "" },
        { "subject_type", "" },
        { "user_guid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/third_party_live_feed_items");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "event_occurred_at=&idempotency_key=&message=&subject_id=&subject_type=&user_guid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/third_party_live_feed_items"

	payload := strings.NewReader("event_occurred_at=&idempotency_key=&message=&subject_id=&subject_type=&user_guid=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/third_party_live_feed_items HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 81

event_occurred_at=&idempotency_key=&message=&subject_id=&subject_type=&user_guid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/third_party_live_feed_items")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("event_occurred_at=&idempotency_key=&message=&subject_id=&subject_type=&user_guid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/third_party_live_feed_items"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("event_occurred_at=&idempotency_key=&message=&subject_id=&subject_type=&user_guid="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "event_occurred_at=&idempotency_key=&message=&subject_id=&subject_type=&user_guid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/third_party_live_feed_items")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/third_party_live_feed_items")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("event_occurred_at=&idempotency_key=&message=&subject_id=&subject_type=&user_guid=")
  .asString();

const data = 'event_occurred_at=&idempotency_key=&message=&subject_id=&subject_type=&user_guid=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/third_party_live_feed_items');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('event_occurred_at', '');
encodedParams.set('idempotency_key', '');
encodedParams.set('message', '');
encodedParams.set('subject_id', '');
encodedParams.set('subject_type', '');
encodedParams.set('user_guid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/third_party_live_feed_items',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/third_party_live_feed_items';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    event_occurred_at: '',
    idempotency_key: '',
    message: '',
    subject_id: '',
    subject_type: '',
    user_guid: ''
  })
};

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}}/v2/third_party_live_feed_items',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    event_occurred_at: '',
    idempotency_key: '',
    message: '',
    subject_id: '',
    subject_type: '',
    user_guid: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "event_occurred_at=&idempotency_key=&message=&subject_id=&subject_type=&user_guid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/third_party_live_feed_items")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/third_party_live_feed_items',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({
  event_occurred_at: '',
  idempotency_key: '',
  message: '',
  subject_id: '',
  subject_type: '',
  user_guid: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/third_party_live_feed_items',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    event_occurred_at: '',
    idempotency_key: '',
    message: '',
    subject_id: '',
    subject_type: '',
    user_guid: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/third_party_live_feed_items');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  event_occurred_at: '',
  idempotency_key: '',
  message: '',
  subject_id: '',
  subject_type: '',
  user_guid: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('event_occurred_at', '');
encodedParams.set('idempotency_key', '');
encodedParams.set('message', '');
encodedParams.set('subject_id', '');
encodedParams.set('subject_type', '');
encodedParams.set('user_guid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/third_party_live_feed_items',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('event_occurred_at', '');
encodedParams.set('idempotency_key', '');
encodedParams.set('message', '');
encodedParams.set('subject_id', '');
encodedParams.set('subject_type', '');
encodedParams.set('user_guid', '');

const url = '{{baseUrl}}/v2/third_party_live_feed_items';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"event_occurred_at=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&idempotency_key=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&message=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&subject_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&subject_type=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&user_guid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/third_party_live_feed_items"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/third_party_live_feed_items" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "event_occurred_at=&idempotency_key=&message=&subject_id=&subject_type=&user_guid=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/third_party_live_feed_items",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "event_occurred_at=&idempotency_key=&message=&subject_id=&subject_type=&user_guid=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/third_party_live_feed_items', [
  'form_params' => [
    'event_occurred_at' => '',
    'idempotency_key' => '',
    'message' => '',
    'subject_id' => '',
    'subject_type' => '',
    'user_guid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/third_party_live_feed_items');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'event_occurred_at' => '',
  'idempotency_key' => '',
  'message' => '',
  'subject_id' => '',
  'subject_type' => '',
  'user_guid' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'event_occurred_at' => '',
  'idempotency_key' => '',
  'message' => '',
  'subject_id' => '',
  'subject_type' => '',
  'user_guid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/third_party_live_feed_items');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/third_party_live_feed_items' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'event_occurred_at=&idempotency_key=&message=&subject_id=&subject_type=&user_guid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/third_party_live_feed_items' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'event_occurred_at=&idempotency_key=&message=&subject_id=&subject_type=&user_guid='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "event_occurred_at=&idempotency_key=&message=&subject_id=&subject_type=&user_guid="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/third_party_live_feed_items", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/third_party_live_feed_items"

payload = {
    "event_occurred_at": "",
    "idempotency_key": "",
    "message": "",
    "subject_id": "",
    "subject_type": "",
    "user_guid": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/third_party_live_feed_items"

payload <- "event_occurred_at=&idempotency_key=&message=&subject_id=&subject_type=&user_guid="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/third_party_live_feed_items")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "event_occurred_at=&idempotency_key=&message=&subject_id=&subject_type=&user_guid="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :event_occurred_at => "",
  :idempotency_key => "",
  :message => "",
  :subject_id => "",
  :subject_type => "",
  :user_guid => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/third_party_live_feed_items') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/third_party_live_feed_items";

    let payload = json!({
        "event_occurred_at": "",
        "idempotency_key": "",
        "message": "",
        "subject_id": "",
        "subject_type": "",
        "user_guid": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/third_party_live_feed_items \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data event_occurred_at= \
  --data idempotency_key= \
  --data message= \
  --data subject_id= \
  --data subject_type= \
  --data user_guid=

http --form POST {{baseUrl}}/v2/third_party_live_feed_items \
  content-type:application/x-www-form-urlencoded \
  event_occurred_at='' \
  idempotency_key='' \
  message='' \
  subject_id='' \
  subject_type='' \
  user_guid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'event_occurred_at=&idempotency_key=&message=&subject_id=&subject_type=&user_guid=' \
  --output-document \
  - {{baseUrl}}/v2/third_party_live_feed_items

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "event_occurred_at=".data(using: String.Encoding.utf8)!)
postData.append("&idempotency_key=".data(using: String.Encoding.utf8)!)
postData.append("&message=".data(using: String.Encoding.utf8)!)
postData.append("&subject_id=".data(using: String.Encoding.utf8)!)
postData.append("&subject_type=".data(using: String.Encoding.utf8)!)
postData.append("&user_guid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/third_party_live_feed_items")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create an Live Website Tracking Parameter

{{baseUrl}}/v2/live_website_tracking_parameters.json

BODY formUrlEncoded

person_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/live_website_tracking_parameters.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "person_id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/live_website_tracking_parameters.json" {:form-params {:person_id ""}})

require "http/client"

url = "{{baseUrl}}/v2/live_website_tracking_parameters.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "person_id="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/live_website_tracking_parameters.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "person_id", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/live_website_tracking_parameters.json");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "person_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/live_website_tracking_parameters.json"

	payload := strings.NewReader("person_id=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/live_website_tracking_parameters.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 10

person_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/live_website_tracking_parameters.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("person_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/live_website_tracking_parameters.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("person_id="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "person_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/live_website_tracking_parameters.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/live_website_tracking_parameters.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("person_id=")
  .asString();

const data = 'person_id=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/live_website_tracking_parameters.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('person_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/live_website_tracking_parameters.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/live_website_tracking_parameters.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({person_id: ''})
};

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}}/v2/live_website_tracking_parameters.json',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    person_id: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "person_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/live_website_tracking_parameters.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/live_website_tracking_parameters.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({person_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/live_website_tracking_parameters.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {person_id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/live_website_tracking_parameters.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  person_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('person_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/live_website_tracking_parameters.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('person_id', '');

const url = '{{baseUrl}}/v2/live_website_tracking_parameters.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"person_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/live_website_tracking_parameters.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/live_website_tracking_parameters.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "person_id=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/live_website_tracking_parameters.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "person_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/live_website_tracking_parameters.json', [
  'form_params' => [
    'person_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/live_website_tracking_parameters.json');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'person_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'person_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/live_website_tracking_parameters.json');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/live_website_tracking_parameters.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'person_id='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/live_website_tracking_parameters.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'person_id='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "person_id="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/live_website_tracking_parameters.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/live_website_tracking_parameters.json"

payload = { "person_id": "" }
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/live_website_tracking_parameters.json"

payload <- "person_id="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/live_website_tracking_parameters.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "person_id="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :person_id => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/live_website_tracking_parameters.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/live_website_tracking_parameters.json";

    let payload = json!({"person_id": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/live_website_tracking_parameters.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data person_id=

http --form POST {{baseUrl}}/v2/live_website_tracking_parameters.json \
  content-type:application/x-www-form-urlencoded \
  person_id=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data person_id= \
  --output-document \
  - {{baseUrl}}/v2/live_website_tracking_parameters.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "person_id=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/live_website_tracking_parameters.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch current user

{{baseUrl}}/v2/me.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/me.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/me.json")

require "http/client"

url = "{{baseUrl}}/v2/me.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/me.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/me.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/me.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/me.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/me.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/me.json"))
    .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}}/v2/me.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/me.json")
  .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}}/v2/me.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/me.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/me.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/me.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/me.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/me.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/me.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/me.json');

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}}/v2/me.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/me.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/me.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/me.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/me.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/me.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/me.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/me.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/me.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/me.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/me.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/me.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/me.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/me.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/me.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/me.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/me.json

http GET {{baseUrl}}/v2/me.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/me.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/me.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT Update a meeting setting

{{baseUrl}}/v2/meetings/settings/:id.json

QUERY PARAMS

BODY formUrlEncoded

allow_booking_on_behalf

allow_booking_overtime

allow_event_overlap

availability_limit

availability_limit_enabled

buffer_time_duration

calendar_type

default_meeting_length

description

enable_calendar_sync

enable_dynamic_location

location

primary_calendar_connection_failed

primary_calendar_id

primary_calendar_name

schedule_buffer_enabled

schedule_delay

share_event_detail

time_zone

times_available

title

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/meetings/settings/:id.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "allow_booking_on_behalf=&allow_booking_overtime=&allow_event_overlap=&availability_limit=&availability_limit_enabled=&buffer_time_duration=&calendar_type=&default_meeting_length=&description=&enable_calendar_sync=&enable_dynamic_location=&location=&primary_calendar_connection_failed=&primary_calendar_id=&primary_calendar_name=&schedule_buffer_enabled=&schedule_delay=&share_event_detail=&time_zone=×_available=&title=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v2/meetings/settings/:id.json" {:form-params {:allow_booking_on_behalf ""
                                                                                       :allow_booking_overtime ""
                                                                                       :allow_event_overlap ""
                                                                                       :availability_limit ""
                                                                                       :availability_limit_enabled ""
                                                                                       :buffer_time_duration ""
                                                                                       :calendar_type ""
                                                                                       :default_meeting_length ""
                                                                                       :description ""
                                                                                       :enable_calendar_sync ""
                                                                                       :enable_dynamic_location ""
                                                                                       :location ""
                                                                                       :primary_calendar_connection_failed ""
                                                                                       :primary_calendar_id ""
                                                                                       :primary_calendar_name ""
                                                                                       :schedule_buffer_enabled ""
                                                                                       :schedule_delay ""
                                                                                       :share_event_detail ""
                                                                                       :time_zone ""
                                                                                       :times_available ""
                                                                                       :title ""}})

require "http/client"

url = "{{baseUrl}}/v2/meetings/settings/:id.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "allow_booking_on_behalf=&allow_booking_overtime=&allow_event_overlap=&availability_limit=&availability_limit_enabled=&buffer_time_duration=&calendar_type=&default_meeting_length=&description=&enable_calendar_sync=&enable_dynamic_location=&location=&primary_calendar_connection_failed=&primary_calendar_id=&primary_calendar_name=&schedule_buffer_enabled=&schedule_delay=&share_event_detail=&time_zone=×_available=&title="

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v2/meetings/settings/:id.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "allow_booking_on_behalf", "" },
        { "allow_booking_overtime", "" },
        { "allow_event_overlap", "" },
        { "availability_limit", "" },
        { "availability_limit_enabled", "" },
        { "buffer_time_duration", "" },
        { "calendar_type", "" },
        { "default_meeting_length", "" },
        { "description", "" },
        { "enable_calendar_sync", "" },
        { "enable_dynamic_location", "" },
        { "location", "" },
        { "primary_calendar_connection_failed", "" },
        { "primary_calendar_id", "" },
        { "primary_calendar_name", "" },
        { "schedule_buffer_enabled", "" },
        { "schedule_delay", "" },
        { "share_event_detail", "" },
        { "time_zone", "" },
        { "times_available", "" },
        { "title", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/meetings/settings/:id.json");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "allow_booking_on_behalf=&allow_booking_overtime=&allow_event_overlap=&availability_limit=&availability_limit_enabled=&buffer_time_duration=&calendar_type=&default_meeting_length=&description=&enable_calendar_sync=&enable_dynamic_location=&location=&primary_calendar_connection_failed=&primary_calendar_id=&primary_calendar_name=&schedule_buffer_enabled=&schedule_delay=&share_event_detail=&time_zone=×_available=&title=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/meetings/settings/:id.json"

	payload := strings.NewReader("allow_booking_on_behalf=&allow_booking_overtime=&allow_event_overlap=&availability_limit=&availability_limit_enabled=&buffer_time_duration=&calendar_type=&default_meeting_length=&description=&enable_calendar_sync=&enable_dynamic_location=&location=&primary_calendar_connection_failed=&primary_calendar_id=&primary_calendar_name=&schedule_buffer_enabled=&schedule_delay=&share_event_detail=&time_zone=×_available=&title=")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/v2/meetings/settings/:id.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 424

allow_booking_on_behalf=&allow_booking_overtime=&allow_event_overlap=&availability_limit=&availability_limit_enabled=&buffer_time_duration=&calendar_type=&default_meeting_length=&description=&enable_calendar_sync=&enable_dynamic_location=&location=&primary_calendar_connection_failed=&primary_calendar_id=&primary_calendar_name=&schedule_buffer_enabled=&schedule_delay=&share_event_detail=&time_zone=×_available=&title=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v2/meetings/settings/:id.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("allow_booking_on_behalf=&allow_booking_overtime=&allow_event_overlap=&availability_limit=&availability_limit_enabled=&buffer_time_duration=&calendar_type=&default_meeting_length=&description=&enable_calendar_sync=&enable_dynamic_location=&location=&primary_calendar_connection_failed=&primary_calendar_id=&primary_calendar_name=&schedule_buffer_enabled=&schedule_delay=&share_event_detail=&time_zone=×_available=&title=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/meetings/settings/:id.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("PUT", HttpRequest.BodyPublishers.ofString("allow_booking_on_behalf=&allow_booking_overtime=&allow_event_overlap=&availability_limit=&availability_limit_enabled=&buffer_time_duration=&calendar_type=&default_meeting_length=&description=&enable_calendar_sync=&enable_dynamic_location=&location=&primary_calendar_connection_failed=&primary_calendar_id=&primary_calendar_name=&schedule_buffer_enabled=&schedule_delay=&share_event_detail=&time_zone=×_available=&title="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "allow_booking_on_behalf=&allow_booking_overtime=&allow_event_overlap=&availability_limit=&availability_limit_enabled=&buffer_time_duration=&calendar_type=&default_meeting_length=&description=&enable_calendar_sync=&enable_dynamic_location=&location=&primary_calendar_connection_failed=&primary_calendar_id=&primary_calendar_name=&schedule_buffer_enabled=&schedule_delay=&share_event_detail=&time_zone=×_available=&title=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/meetings/settings/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v2/meetings/settings/:id.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("allow_booking_on_behalf=&allow_booking_overtime=&allow_event_overlap=&availability_limit=&availability_limit_enabled=&buffer_time_duration=&calendar_type=&default_meeting_length=&description=&enable_calendar_sync=&enable_dynamic_location=&location=&primary_calendar_connection_failed=&primary_calendar_id=&primary_calendar_name=&schedule_buffer_enabled=&schedule_delay=&share_event_detail=&time_zone=×_available=&title=")
  .asString();

const data = 'allow_booking_on_behalf=&allow_booking_overtime=&allow_event_overlap=&availability_limit=&availability_limit_enabled=&buffer_time_duration=&calendar_type=&default_meeting_length=&description=&enable_calendar_sync=&enable_dynamic_location=&location=&primary_calendar_connection_failed=&primary_calendar_id=&primary_calendar_name=&schedule_buffer_enabled=&schedule_delay=&share_event_detail=&time_zone=×_available=&title=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v2/meetings/settings/:id.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('allow_booking_on_behalf', '');
encodedParams.set('allow_booking_overtime', '');
encodedParams.set('allow_event_overlap', '');
encodedParams.set('availability_limit', '');
encodedParams.set('availability_limit_enabled', '');
encodedParams.set('buffer_time_duration', '');
encodedParams.set('calendar_type', '');
encodedParams.set('default_meeting_length', '');
encodedParams.set('description', '');
encodedParams.set('enable_calendar_sync', '');
encodedParams.set('enable_dynamic_location', '');
encodedParams.set('location', '');
encodedParams.set('primary_calendar_connection_failed', '');
encodedParams.set('primary_calendar_id', '');
encodedParams.set('primary_calendar_name', '');
encodedParams.set('schedule_buffer_enabled', '');
encodedParams.set('schedule_delay', '');
encodedParams.set('share_event_detail', '');
encodedParams.set('time_zone', '');
encodedParams.set('times_available', '');
encodedParams.set('title', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/meetings/settings/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/meetings/settings/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    allow_booking_on_behalf: '',
    allow_booking_overtime: '',
    allow_event_overlap: '',
    availability_limit: '',
    availability_limit_enabled: '',
    buffer_time_duration: '',
    calendar_type: '',
    default_meeting_length: '',
    description: '',
    enable_calendar_sync: '',
    enable_dynamic_location: '',
    location: '',
    primary_calendar_connection_failed: '',
    primary_calendar_id: '',
    primary_calendar_name: '',
    schedule_buffer_enabled: '',
    schedule_delay: '',
    share_event_detail: '',
    time_zone: '',
    times_available: '',
    title: ''
  })
};

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}}/v2/meetings/settings/:id.json',
  method: 'PUT',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    allow_booking_on_behalf: '',
    allow_booking_overtime: '',
    allow_event_overlap: '',
    availability_limit: '',
    availability_limit_enabled: '',
    buffer_time_duration: '',
    calendar_type: '',
    default_meeting_length: '',
    description: '',
    enable_calendar_sync: '',
    enable_dynamic_location: '',
    location: '',
    primary_calendar_connection_failed: '',
    primary_calendar_id: '',
    primary_calendar_name: '',
    schedule_buffer_enabled: '',
    schedule_delay: '',
    share_event_detail: '',
    time_zone: '',
    times_available: '',
    title: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "allow_booking_on_behalf=&allow_booking_overtime=&allow_event_overlap=&availability_limit=&availability_limit_enabled=&buffer_time_duration=&calendar_type=&default_meeting_length=&description=&enable_calendar_sync=&enable_dynamic_location=&location=&primary_calendar_connection_failed=&primary_calendar_id=&primary_calendar_name=&schedule_buffer_enabled=&schedule_delay=&share_event_detail=&time_zone=×_available=&title=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/meetings/settings/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/meetings/settings/:id.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({
  allow_booking_on_behalf: '',
  allow_booking_overtime: '',
  allow_event_overlap: '',
  availability_limit: '',
  availability_limit_enabled: '',
  buffer_time_duration: '',
  calendar_type: '',
  default_meeting_length: '',
  description: '',
  enable_calendar_sync: '',
  enable_dynamic_location: '',
  location: '',
  primary_calendar_connection_failed: '',
  primary_calendar_id: '',
  primary_calendar_name: '',
  schedule_buffer_enabled: '',
  schedule_delay: '',
  share_event_detail: '',
  time_zone: '',
  times_available: '',
  title: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/meetings/settings/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    allow_booking_on_behalf: '',
    allow_booking_overtime: '',
    allow_event_overlap: '',
    availability_limit: '',
    availability_limit_enabled: '',
    buffer_time_duration: '',
    calendar_type: '',
    default_meeting_length: '',
    description: '',
    enable_calendar_sync: '',
    enable_dynamic_location: '',
    location: '',
    primary_calendar_connection_failed: '',
    primary_calendar_id: '',
    primary_calendar_name: '',
    schedule_buffer_enabled: '',
    schedule_delay: '',
    share_event_detail: '',
    time_zone: '',
    times_available: '',
    title: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/v2/meetings/settings/:id.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  allow_booking_on_behalf: '',
  allow_booking_overtime: '',
  allow_event_overlap: '',
  availability_limit: '',
  availability_limit_enabled: '',
  buffer_time_duration: '',
  calendar_type: '',
  default_meeting_length: '',
  description: '',
  enable_calendar_sync: '',
  enable_dynamic_location: '',
  location: '',
  primary_calendar_connection_failed: '',
  primary_calendar_id: '',
  primary_calendar_name: '',
  schedule_buffer_enabled: '',
  schedule_delay: '',
  share_event_detail: '',
  time_zone: '',
  times_available: '',
  title: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('allow_booking_on_behalf', '');
encodedParams.set('allow_booking_overtime', '');
encodedParams.set('allow_event_overlap', '');
encodedParams.set('availability_limit', '');
encodedParams.set('availability_limit_enabled', '');
encodedParams.set('buffer_time_duration', '');
encodedParams.set('calendar_type', '');
encodedParams.set('default_meeting_length', '');
encodedParams.set('description', '');
encodedParams.set('enable_calendar_sync', '');
encodedParams.set('enable_dynamic_location', '');
encodedParams.set('location', '');
encodedParams.set('primary_calendar_connection_failed', '');
encodedParams.set('primary_calendar_id', '');
encodedParams.set('primary_calendar_name', '');
encodedParams.set('schedule_buffer_enabled', '');
encodedParams.set('schedule_delay', '');
encodedParams.set('share_event_detail', '');
encodedParams.set('time_zone', '');
encodedParams.set('times_available', '');
encodedParams.set('title', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/meetings/settings/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('allow_booking_on_behalf', '');
encodedParams.set('allow_booking_overtime', '');
encodedParams.set('allow_event_overlap', '');
encodedParams.set('availability_limit', '');
encodedParams.set('availability_limit_enabled', '');
encodedParams.set('buffer_time_duration', '');
encodedParams.set('calendar_type', '');
encodedParams.set('default_meeting_length', '');
encodedParams.set('description', '');
encodedParams.set('enable_calendar_sync', '');
encodedParams.set('enable_dynamic_location', '');
encodedParams.set('location', '');
encodedParams.set('primary_calendar_connection_failed', '');
encodedParams.set('primary_calendar_id', '');
encodedParams.set('primary_calendar_name', '');
encodedParams.set('schedule_buffer_enabled', '');
encodedParams.set('schedule_delay', '');
encodedParams.set('share_event_detail', '');
encodedParams.set('time_zone', '');
encodedParams.set('times_available', '');
encodedParams.set('title', '');

const url = '{{baseUrl}}/v2/meetings/settings/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"allow_booking_on_behalf=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&allow_booking_overtime=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&allow_event_overlap=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&availability_limit=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&availability_limit_enabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&buffer_time_duration=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&calendar_type=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&default_meeting_length=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&description=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&enable_calendar_sync=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&enable_dynamic_location=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&location=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&primary_calendar_connection_failed=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&primary_calendar_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&primary_calendar_name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&schedule_buffer_enabled=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&schedule_delay=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&share_event_detail=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&time_zone=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"×_available=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&title=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/meetings/settings/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/meetings/settings/:id.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "allow_booking_on_behalf=&allow_booking_overtime=&allow_event_overlap=&availability_limit=&availability_limit_enabled=&buffer_time_duration=&calendar_type=&default_meeting_length=&description=&enable_calendar_sync=&enable_dynamic_location=&location=&primary_calendar_connection_failed=&primary_calendar_id=&primary_calendar_name=&schedule_buffer_enabled=&schedule_delay=&share_event_detail=&time_zone=×_available=&title=" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/meetings/settings/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => "allow_booking_on_behalf=&allow_booking_overtime=&allow_event_overlap=&availability_limit=&availability_limit_enabled=&buffer_time_duration=&calendar_type=&default_meeting_length=&description=&enable_calendar_sync=&enable_dynamic_location=&location=&primary_calendar_connection_failed=&primary_calendar_id=&primary_calendar_name=&schedule_buffer_enabled=&schedule_delay=&share_event_detail=&time_zone=×_available=&title=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/v2/meetings/settings/:id.json', [
  'form_params' => [
    'allow_booking_on_behalf' => '',
    'allow_booking_overtime' => '',
    'allow_event_overlap' => '',
    'availability_limit' => '',
    'availability_limit_enabled' => '',
    'buffer_time_duration' => '',
    'calendar_type' => '',
    'default_meeting_length' => '',
    'description' => '',
    'enable_calendar_sync' => '',
    'enable_dynamic_location' => '',
    'location' => '',
    'primary_calendar_connection_failed' => '',
    'primary_calendar_id' => '',
    'primary_calendar_name' => '',
    'schedule_buffer_enabled' => '',
    'schedule_delay' => '',
    'share_event_detail' => '',
    'time_zone' => '',
    'times_available' => '',
    'title' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/meetings/settings/:id.json');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'allow_booking_on_behalf' => '',
  'allow_booking_overtime' => '',
  'allow_event_overlap' => '',
  'availability_limit' => '',
  'availability_limit_enabled' => '',
  'buffer_time_duration' => '',
  'calendar_type' => '',
  'default_meeting_length' => '',
  'description' => '',
  'enable_calendar_sync' => '',
  'enable_dynamic_location' => '',
  'location' => '',
  'primary_calendar_connection_failed' => '',
  'primary_calendar_id' => '',
  'primary_calendar_name' => '',
  'schedule_buffer_enabled' => '',
  'schedule_delay' => '',
  'share_event_detail' => '',
  'time_zone' => '',
  'times_available' => '',
  'title' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'allow_booking_on_behalf' => '',
  'allow_booking_overtime' => '',
  'allow_event_overlap' => '',
  'availability_limit' => '',
  'availability_limit_enabled' => '',
  'buffer_time_duration' => '',
  'calendar_type' => '',
  'default_meeting_length' => '',
  'description' => '',
  'enable_calendar_sync' => '',
  'enable_dynamic_location' => '',
  'location' => '',
  'primary_calendar_connection_failed' => '',
  'primary_calendar_id' => '',
  'primary_calendar_name' => '',
  'schedule_buffer_enabled' => '',
  'schedule_delay' => '',
  'share_event_detail' => '',
  'time_zone' => '',
  'times_available' => '',
  'title' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/meetings/settings/:id.json');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/meetings/settings/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'allow_booking_on_behalf=&allow_booking_overtime=&allow_event_overlap=&availability_limit=&availability_limit_enabled=&buffer_time_duration=&calendar_type=&default_meeting_length=&description=&enable_calendar_sync=&enable_dynamic_location=&location=&primary_calendar_connection_failed=&primary_calendar_id=&primary_calendar_name=&schedule_buffer_enabled=&schedule_delay=&share_event_detail=&time_zone=×_available=&title='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/meetings/settings/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'allow_booking_on_behalf=&allow_booking_overtime=&allow_event_overlap=&availability_limit=&availability_limit_enabled=&buffer_time_duration=&calendar_type=&default_meeting_length=&description=&enable_calendar_sync=&enable_dynamic_location=&location=&primary_calendar_connection_failed=&primary_calendar_id=&primary_calendar_name=&schedule_buffer_enabled=&schedule_delay=&share_event_detail=&time_zone=×_available=&title='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "allow_booking_on_behalf=&allow_booking_overtime=&allow_event_overlap=&availability_limit=&availability_limit_enabled=&buffer_time_duration=&calendar_type=&default_meeting_length=&description=&enable_calendar_sync=&enable_dynamic_location=&location=&primary_calendar_connection_failed=&primary_calendar_id=&primary_calendar_name=&schedule_buffer_enabled=&schedule_delay=&share_event_detail=&time_zone=×_available=&title="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PUT", "/baseUrl/v2/meetings/settings/:id.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/meetings/settings/:id.json"

payload = {
    "allow_booking_on_behalf": "",
    "allow_booking_overtime": "",
    "allow_event_overlap": "",
    "availability_limit": "",
    "availability_limit_enabled": "",
    "buffer_time_duration": "",
    "calendar_type": "",
    "default_meeting_length": "",
    "description": "",
    "enable_calendar_sync": "",
    "enable_dynamic_location": "",
    "location": "",
    "primary_calendar_connection_failed": "",
    "primary_calendar_id": "",
    "primary_calendar_name": "",
    "schedule_buffer_enabled": "",
    "schedule_delay": "",
    "share_event_detail": "",
    "time_zone": "",
    "times_available": "",
    "title": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.put(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/meetings/settings/:id.json"

payload <- "allow_booking_on_behalf=&allow_booking_overtime=&allow_event_overlap=&availability_limit=&availability_limit_enabled=&buffer_time_duration=&calendar_type=&default_meeting_length=&description=&enable_calendar_sync=&enable_dynamic_location=&location=&primary_calendar_connection_failed=&primary_calendar_id=&primary_calendar_name=&schedule_buffer_enabled=&schedule_delay=&share_event_detail=&time_zone=×_available=&title="

encode <- "form"

response <- VERB("PUT", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/meetings/settings/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "allow_booking_on_behalf=&allow_booking_overtime=&allow_event_overlap=&availability_limit=&availability_limit_enabled=&buffer_time_duration=&calendar_type=&default_meeting_length=&description=&enable_calendar_sync=&enable_dynamic_location=&location=&primary_calendar_connection_failed=&primary_calendar_id=&primary_calendar_name=&schedule_buffer_enabled=&schedule_delay=&share_event_detail=&time_zone=×_available=&title="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :allow_booking_on_behalf => "",
  :allow_booking_overtime => "",
  :allow_event_overlap => "",
  :availability_limit => "",
  :availability_limit_enabled => "",
  :buffer_time_duration => "",
  :calendar_type => "",
  :default_meeting_length => "",
  :description => "",
  :enable_calendar_sync => "",
  :enable_dynamic_location => "",
  :location => "",
  :primary_calendar_connection_failed => "",
  :primary_calendar_id => "",
  :primary_calendar_name => "",
  :schedule_buffer_enabled => "",
  :schedule_delay => "",
  :share_event_detail => "",
  :time_zone => "",
  :times_available => "",
  :title => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.put('/baseUrl/v2/meetings/settings/:id.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/meetings/settings/:id.json";

    let payload = json!({
        "allow_booking_on_behalf": "",
        "allow_booking_overtime": "",
        "allow_event_overlap": "",
        "availability_limit": "",
        "availability_limit_enabled": "",
        "buffer_time_duration": "",
        "calendar_type": "",
        "default_meeting_length": "",
        "description": "",
        "enable_calendar_sync": "",
        "enable_dynamic_location": "",
        "location": "",
        "primary_calendar_connection_failed": "",
        "primary_calendar_id": "",
        "primary_calendar_name": "",
        "schedule_buffer_enabled": "",
        "schedule_delay": "",
        "share_event_detail": "",
        "time_zone": "",
        "times_available": "",
        "title": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/v2/meetings/settings/:id.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data allow_booking_on_behalf= \
  --data allow_booking_overtime= \
  --data allow_event_overlap= \
  --data availability_limit= \
  --data availability_limit_enabled= \
  --data buffer_time_duration= \
  --data calendar_type= \
  --data default_meeting_length= \
  --data description= \
  --data enable_calendar_sync= \
  --data enable_dynamic_location= \
  --data location= \
  --data primary_calendar_connection_failed= \
  --data primary_calendar_id= \
  --data primary_calendar_name= \
  --data schedule_buffer_enabled= \
  --data schedule_delay= \
  --data share_event_detail= \
  --data time_zone= \
  --data times_available= \
  --data title=

http --form PUT {{baseUrl}}/v2/meetings/settings/:id.json \
  content-type:application/x-www-form-urlencoded \
  allow_booking_on_behalf='' \
  allow_booking_overtime='' \
  allow_event_overlap='' \
  availability_limit='' \
  availability_limit_enabled='' \
  buffer_time_duration='' \
  calendar_type='' \
  default_meeting_length='' \
  description='' \
  enable_calendar_sync='' \
  enable_dynamic_location='' \
  location='' \
  primary_calendar_connection_failed='' \
  primary_calendar_id='' \
  primary_calendar_name='' \
  schedule_buffer_enabled='' \
  schedule_delay='' \
  share_event_detail='' \
  time_zone='' \
  times_available='' \
  title=''

wget --quiet \
  --method PUT \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'allow_booking_on_behalf=&allow_booking_overtime=&allow_event_overlap=&availability_limit=&availability_limit_enabled=&buffer_time_duration=&calendar_type=&default_meeting_length=&description=&enable_calendar_sync=&enable_dynamic_location=&location=&primary_calendar_connection_failed=&primary_calendar_id=&primary_calendar_name=&schedule_buffer_enabled=&schedule_delay=&share_event_detail=&time_zone=×_available=&title=' \
  --output-document \
  - {{baseUrl}}/v2/meetings/settings/:id.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "allow_booking_on_behalf=".data(using: String.Encoding.utf8)!)
postData.append("&allow_booking_overtime=".data(using: String.Encoding.utf8)!)
postData.append("&allow_event_overlap=".data(using: String.Encoding.utf8)!)
postData.append("&availability_limit=".data(using: String.Encoding.utf8)!)
postData.append("&availability_limit_enabled=".data(using: String.Encoding.utf8)!)
postData.append("&buffer_time_duration=".data(using: String.Encoding.utf8)!)
postData.append("&calendar_type=".data(using: String.Encoding.utf8)!)
postData.append("&default_meeting_length=".data(using: String.Encoding.utf8)!)
postData.append("&description=".data(using: String.Encoding.utf8)!)
postData.append("&enable_calendar_sync=".data(using: String.Encoding.utf8)!)
postData.append("&enable_dynamic_location=".data(using: String.Encoding.utf8)!)
postData.append("&location=".data(using: String.Encoding.utf8)!)
postData.append("&primary_calendar_connection_failed=".data(using: String.Encoding.utf8)!)
postData.append("&primary_calendar_id=".data(using: String.Encoding.utf8)!)
postData.append("&primary_calendar_name=".data(using: String.Encoding.utf8)!)
postData.append("&schedule_buffer_enabled=".data(using: String.Encoding.utf8)!)
postData.append("&schedule_delay=".data(using: String.Encoding.utf8)!)
postData.append("&share_event_detail=".data(using: String.Encoding.utf8)!)
postData.append("&time_zone=".data(using: String.Encoding.utf8)!)
postData.append("×_available=".data(using: String.Encoding.utf8)!)
postData.append("&title=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/meetings/settings/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List meetings

{{baseUrl}}/v2/meetings.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/meetings.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/meetings.json")

require "http/client"

url = "{{baseUrl}}/v2/meetings.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/meetings.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/meetings.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/meetings.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/meetings.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/meetings.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/meetings.json"))
    .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}}/v2/meetings.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/meetings.json")
  .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}}/v2/meetings.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/meetings.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/meetings.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/meetings.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/meetings.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/meetings.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/meetings.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/meetings.json');

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}}/v2/meetings.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/meetings.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/meetings.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/meetings.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/meetings.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/meetings.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/meetings.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/meetings.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/meetings.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/meetings.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/meetings.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/meetings.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/meetings.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/meetings.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/meetings.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/meetings.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/meetings.json

http GET {{baseUrl}}/v2/meetings.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/meetings.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/meetings.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT Update a meeting

{{baseUrl}}/v2/meetings/:id.json

QUERY PARAMS

BODY formUrlEncoded

event_id

i_cal_uid

no_show

status

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/meetings/:id.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "event_id=&i_cal_uid=&no_show=&status=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v2/meetings/:id.json" {:form-params {:event_id ""
                                                                              :i_cal_uid ""
                                                                              :no_show ""
                                                                              :status ""}})

require "http/client"

url = "{{baseUrl}}/v2/meetings/:id.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "event_id=&i_cal_uid=&no_show=&status="

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v2/meetings/:id.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "event_id", "" },
        { "i_cal_uid", "" },
        { "no_show", "" },
        { "status", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/meetings/:id.json");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "event_id=&i_cal_uid=&no_show=&status=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/meetings/:id.json"

	payload := strings.NewReader("event_id=&i_cal_uid=&no_show=&status=")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/v2/meetings/:id.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 37

event_id=&i_cal_uid=&no_show=&status=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v2/meetings/:id.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("event_id=&i_cal_uid=&no_show=&status=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/meetings/:id.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("PUT", HttpRequest.BodyPublishers.ofString("event_id=&i_cal_uid=&no_show=&status="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "event_id=&i_cal_uid=&no_show=&status=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/meetings/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v2/meetings/:id.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("event_id=&i_cal_uid=&no_show=&status=")
  .asString();

const data = 'event_id=&i_cal_uid=&no_show=&status=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v2/meetings/:id.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('event_id', '');
encodedParams.set('i_cal_uid', '');
encodedParams.set('no_show', '');
encodedParams.set('status', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/meetings/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/meetings/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({event_id: '', i_cal_uid: '', no_show: '', status: ''})
};

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}}/v2/meetings/:id.json',
  method: 'PUT',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    event_id: '',
    i_cal_uid: '',
    no_show: '',
    status: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "event_id=&i_cal_uid=&no_show=&status=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/meetings/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/meetings/:id.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({event_id: '', i_cal_uid: '', no_show: '', status: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/meetings/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {event_id: '', i_cal_uid: '', no_show: '', status: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/v2/meetings/:id.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  event_id: '',
  i_cal_uid: '',
  no_show: '',
  status: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('event_id', '');
encodedParams.set('i_cal_uid', '');
encodedParams.set('no_show', '');
encodedParams.set('status', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/meetings/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('event_id', '');
encodedParams.set('i_cal_uid', '');
encodedParams.set('no_show', '');
encodedParams.set('status', '');

const url = '{{baseUrl}}/v2/meetings/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"event_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&i_cal_uid=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&no_show=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&status=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/meetings/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/meetings/:id.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "event_id=&i_cal_uid=&no_show=&status=" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/meetings/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => "event_id=&i_cal_uid=&no_show=&status=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/v2/meetings/:id.json', [
  'form_params' => [
    'event_id' => '',
    'i_cal_uid' => '',
    'no_show' => '',
    'status' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/meetings/:id.json');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'event_id' => '',
  'i_cal_uid' => '',
  'no_show' => '',
  'status' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'event_id' => '',
  'i_cal_uid' => '',
  'no_show' => '',
  'status' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/meetings/:id.json');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/meetings/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'event_id=&i_cal_uid=&no_show=&status='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/meetings/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'event_id=&i_cal_uid=&no_show=&status='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "event_id=&i_cal_uid=&no_show=&status="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PUT", "/baseUrl/v2/meetings/:id.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/meetings/:id.json"

payload = {
    "event_id": "",
    "i_cal_uid": "",
    "no_show": "",
    "status": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.put(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/meetings/:id.json"

payload <- "event_id=&i_cal_uid=&no_show=&status="

encode <- "form"

response <- VERB("PUT", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/meetings/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "event_id=&i_cal_uid=&no_show=&status="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :event_id => "",
  :i_cal_uid => "",
  :no_show => "",
  :status => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.put('/baseUrl/v2/meetings/:id.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/meetings/:id.json";

    let payload = json!({
        "event_id": "",
        "i_cal_uid": "",
        "no_show": "",
        "status": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/v2/meetings/:id.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data event_id= \
  --data i_cal_uid= \
  --data no_show= \
  --data status=

http --form PUT {{baseUrl}}/v2/meetings/:id.json \
  content-type:application/x-www-form-urlencoded \
  event_id='' \
  i_cal_uid='' \
  no_show='' \
  status=''

wget --quiet \
  --method PUT \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'event_id=&i_cal_uid=&no_show=&status=' \
  --output-document \
  - {{baseUrl}}/v2/meetings/:id.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "event_id=".data(using: String.Encoding.utf8)!)
postData.append("&i_cal_uid=".data(using: String.Encoding.utf8)!)
postData.append("&no_show=".data(using: String.Encoding.utf8)!)
postData.append("&status=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/meetings/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST List meeting settings

{{baseUrl}}/v2/meetings/settings/searches.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/meetings/settings/searches.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/meetings/settings/searches.json")

require "http/client"

url = "{{baseUrl}}/v2/meetings/settings/searches.json"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/meetings/settings/searches.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/meetings/settings/searches.json");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/meetings/settings/searches.json"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/meetings/settings/searches.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/meetings/settings/searches.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/meetings/settings/searches.json"))
    .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}}/v2/meetings/settings/searches.json")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/meetings/settings/searches.json")
  .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}}/v2/meetings/settings/searches.json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/meetings/settings/searches.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/meetings/settings/searches.json';
const options = {method: 'POST'};

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}}/v2/meetings/settings/searches.json',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/meetings/settings/searches.json")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/meetings/settings/searches.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/meetings/settings/searches.json'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/meetings/settings/searches.json');

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}}/v2/meetings/settings/searches.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/meetings/settings/searches.json';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/meetings/settings/searches.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/v2/meetings/settings/searches.json" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/meetings/settings/searches.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/meetings/settings/searches.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/meetings/settings/searches.json');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/meetings/settings/searches.json');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/meetings/settings/searches.json' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/meetings/settings/searches.json' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/v2/meetings/settings/searches.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/meetings/settings/searches.json"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/meetings/settings/searches.json"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/meetings/settings/searches.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/v2/meetings/settings/searches.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/meetings/settings/searches.json";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/meetings/settings/searches.json

http POST {{baseUrl}}/v2/meetings/settings/searches.json

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v2/meetings/settings/searches.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/meetings/settings/searches.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 the MIME content for email

{{baseUrl}}/v2/mime_email_payloads/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/mime_email_payloads/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/mime_email_payloads/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/mime_email_payloads/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/mime_email_payloads/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/mime_email_payloads/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/mime_email_payloads/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/mime_email_payloads/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/mime_email_payloads/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/mime_email_payloads/:id.json"))
    .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}}/v2/mime_email_payloads/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/mime_email_payloads/:id.json")
  .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}}/v2/mime_email_payloads/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/mime_email_payloads/:id.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/mime_email_payloads/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/mime_email_payloads/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/mime_email_payloads/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/mime_email_payloads/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/mime_email_payloads/:id.json'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/mime_email_payloads/:id.json');

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}}/v2/mime_email_payloads/:id.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/mime_email_payloads/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/mime_email_payloads/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/mime_email_payloads/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/mime_email_payloads/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/mime_email_payloads/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/mime_email_payloads/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/mime_email_payloads/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/mime_email_payloads/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/mime_email_payloads/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/mime_email_payloads/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/mime_email_payloads/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/mime_email_payloads/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/mime_email_payloads/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/mime_email_payloads/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/mime_email_payloads/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/mime_email_payloads/:id.json

http GET {{baseUrl}}/v2/mime_email_payloads/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/mime_email_payloads/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/mime_email_payloads/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create a note

{{baseUrl}}/v2/notes.json

BODY formUrlEncoded

associated_with_id

associated_with_type

call_id

content

skip_crm_sync

subject

user_guid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/notes.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "associated_with_id=&associated_with_type=&call_id=&content=&skip_crm_sync=&subject=&user_guid=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/notes.json" {:form-params {:associated_with_id ""
                                                                        :associated_with_type ""
                                                                        :call_id ""
                                                                        :content ""
                                                                        :skip_crm_sync ""
                                                                        :subject ""
                                                                        :user_guid ""}})

require "http/client"

url = "{{baseUrl}}/v2/notes.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "associated_with_id=&associated_with_type=&call_id=&content=&skip_crm_sync=&subject=&user_guid="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/notes.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "associated_with_id", "" },
        { "associated_with_type", "" },
        { "call_id", "" },
        { "content", "" },
        { "skip_crm_sync", "" },
        { "subject", "" },
        { "user_guid", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/notes.json");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "associated_with_id=&associated_with_type=&call_id=&content=&skip_crm_sync=&subject=&user_guid=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/notes.json"

	payload := strings.NewReader("associated_with_id=&associated_with_type=&call_id=&content=&skip_crm_sync=&subject=&user_guid=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/notes.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 94

associated_with_id=&associated_with_type=&call_id=&content=&skip_crm_sync=&subject=&user_guid=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/notes.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("associated_with_id=&associated_with_type=&call_id=&content=&skip_crm_sync=&subject=&user_guid=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/notes.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("associated_with_id=&associated_with_type=&call_id=&content=&skip_crm_sync=&subject=&user_guid="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "associated_with_id=&associated_with_type=&call_id=&content=&skip_crm_sync=&subject=&user_guid=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/notes.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/notes.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("associated_with_id=&associated_with_type=&call_id=&content=&skip_crm_sync=&subject=&user_guid=")
  .asString();

const data = 'associated_with_id=&associated_with_type=&call_id=&content=&skip_crm_sync=&subject=&user_guid=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/notes.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('associated_with_id', '');
encodedParams.set('associated_with_type', '');
encodedParams.set('call_id', '');
encodedParams.set('content', '');
encodedParams.set('skip_crm_sync', '');
encodedParams.set('subject', '');
encodedParams.set('user_guid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/notes.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/notes.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    associated_with_id: '',
    associated_with_type: '',
    call_id: '',
    content: '',
    skip_crm_sync: '',
    subject: '',
    user_guid: ''
  })
};

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}}/v2/notes.json',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    associated_with_id: '',
    associated_with_type: '',
    call_id: '',
    content: '',
    skip_crm_sync: '',
    subject: '',
    user_guid: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "associated_with_id=&associated_with_type=&call_id=&content=&skip_crm_sync=&subject=&user_guid=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/notes.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/notes.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({
  associated_with_id: '',
  associated_with_type: '',
  call_id: '',
  content: '',
  skip_crm_sync: '',
  subject: '',
  user_guid: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/notes.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    associated_with_id: '',
    associated_with_type: '',
    call_id: '',
    content: '',
    skip_crm_sync: '',
    subject: '',
    user_guid: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/notes.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  associated_with_id: '',
  associated_with_type: '',
  call_id: '',
  content: '',
  skip_crm_sync: '',
  subject: '',
  user_guid: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('associated_with_id', '');
encodedParams.set('associated_with_type', '');
encodedParams.set('call_id', '');
encodedParams.set('content', '');
encodedParams.set('skip_crm_sync', '');
encodedParams.set('subject', '');
encodedParams.set('user_guid', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/notes.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('associated_with_id', '');
encodedParams.set('associated_with_type', '');
encodedParams.set('call_id', '');
encodedParams.set('content', '');
encodedParams.set('skip_crm_sync', '');
encodedParams.set('subject', '');
encodedParams.set('user_guid', '');

const url = '{{baseUrl}}/v2/notes.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"associated_with_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&associated_with_type=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&call_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&content=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&skip_crm_sync=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&subject=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&user_guid=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/notes.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/notes.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "associated_with_id=&associated_with_type=&call_id=&content=&skip_crm_sync=&subject=&user_guid=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/notes.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "associated_with_id=&associated_with_type=&call_id=&content=&skip_crm_sync=&subject=&user_guid=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/notes.json', [
  'form_params' => [
    'associated_with_id' => '',
    'associated_with_type' => '',
    'call_id' => '',
    'content' => '',
    'skip_crm_sync' => '',
    'subject' => '',
    'user_guid' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/notes.json');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'associated_with_id' => '',
  'associated_with_type' => '',
  'call_id' => '',
  'content' => '',
  'skip_crm_sync' => '',
  'subject' => '',
  'user_guid' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'associated_with_id' => '',
  'associated_with_type' => '',
  'call_id' => '',
  'content' => '',
  'skip_crm_sync' => '',
  'subject' => '',
  'user_guid' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/notes.json');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/notes.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'associated_with_id=&associated_with_type=&call_id=&content=&skip_crm_sync=&subject=&user_guid='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/notes.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'associated_with_id=&associated_with_type=&call_id=&content=&skip_crm_sync=&subject=&user_guid='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "associated_with_id=&associated_with_type=&call_id=&content=&skip_crm_sync=&subject=&user_guid="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/notes.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/notes.json"

payload = {
    "associated_with_id": "",
    "associated_with_type": "",
    "call_id": "",
    "content": "",
    "skip_crm_sync": "",
    "subject": "",
    "user_guid": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/notes.json"

payload <- "associated_with_id=&associated_with_type=&call_id=&content=&skip_crm_sync=&subject=&user_guid="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/notes.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "associated_with_id=&associated_with_type=&call_id=&content=&skip_crm_sync=&subject=&user_guid="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :associated_with_id => "",
  :associated_with_type => "",
  :call_id => "",
  :content => "",
  :skip_crm_sync => "",
  :subject => "",
  :user_guid => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/notes.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/notes.json";

    let payload = json!({
        "associated_with_id": "",
        "associated_with_type": "",
        "call_id": "",
        "content": "",
        "skip_crm_sync": "",
        "subject": "",
        "user_guid": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/notes.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data associated_with_id= \
  --data associated_with_type= \
  --data call_id= \
  --data content= \
  --data skip_crm_sync= \
  --data subject= \
  --data user_guid=

http --form POST {{baseUrl}}/v2/notes.json \
  content-type:application/x-www-form-urlencoded \
  associated_with_id='' \
  associated_with_type='' \
  call_id='' \
  content='' \
  skip_crm_sync='' \
  subject='' \
  user_guid=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'associated_with_id=&associated_with_type=&call_id=&content=&skip_crm_sync=&subject=&user_guid=' \
  --output-document \
  - {{baseUrl}}/v2/notes.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "associated_with_id=".data(using: String.Encoding.utf8)!)
postData.append("&associated_with_type=".data(using: String.Encoding.utf8)!)
postData.append("&call_id=".data(using: String.Encoding.utf8)!)
postData.append("&content=".data(using: String.Encoding.utf8)!)
postData.append("&skip_crm_sync=".data(using: String.Encoding.utf8)!)
postData.append("&subject=".data(using: String.Encoding.utf8)!)
postData.append("&user_guid=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/notes.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Delete a note

{{baseUrl}}/v2/notes/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/notes/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v2/notes/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/notes/:id.json"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v2/notes/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/notes/:id.json");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/notes/:id.json"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v2/notes/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/notes/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/notes/:id.json"))
    .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}}/v2/notes/:id.json")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v2/notes/:id.json")
  .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}}/v2/notes/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v2/notes/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/notes/:id.json';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/notes/:id.json',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/notes/:id.json")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/notes/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/v2/notes/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/notes/:id.json');

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}}/v2/notes/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/notes/:id.json';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/notes/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/notes/:id.json" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/notes/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v2/notes/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/notes/:id.json');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/notes/:id.json');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/notes/:id.json' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/notes/:id.json' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v2/notes/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/notes/:id.json"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/notes/:id.json"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/notes/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v2/notes/:id.json') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/notes/:id.json";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v2/notes/:id.json

http DELETE {{baseUrl}}/v2/notes/:id.json

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/notes/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/notes/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch a note

{{baseUrl}}/v2/notes/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/notes/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/notes/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/notes/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/notes/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/notes/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/notes/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/notes/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/notes/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/notes/:id.json"))
    .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}}/v2/notes/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/notes/:id.json")
  .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}}/v2/notes/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/notes/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/notes/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/notes/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/notes/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/notes/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/notes/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/notes/:id.json');

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}}/v2/notes/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/notes/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/notes/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/notes/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/notes/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/notes/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/notes/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/notes/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/notes/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/notes/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/notes/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/notes/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/notes/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/notes/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/notes/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/notes/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/notes/:id.json

http GET {{baseUrl}}/v2/notes/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/notes/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/notes/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List notes

{{baseUrl}}/v2/notes.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/notes.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/notes.json")

require "http/client"

url = "{{baseUrl}}/v2/notes.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/notes.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/notes.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/notes.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/notes.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/notes.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/notes.json"))
    .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}}/v2/notes.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/notes.json")
  .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}}/v2/notes.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/notes.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/notes.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/notes.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/notes.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/notes.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/notes.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/notes.json');

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}}/v2/notes.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/notes.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/notes.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/notes.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/notes.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/notes.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/notes.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/notes.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/notes.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/notes.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/notes.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/notes.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/notes.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/notes.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/notes.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/notes.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/notes.json

http GET {{baseUrl}}/v2/notes.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/notes.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/notes.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT Update a note

{{baseUrl}}/v2/notes/:id.json

QUERY PARAMS

BODY formUrlEncoded

call_id

content

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/notes/:id.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "call_id=&content=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v2/notes/:id.json" {:form-params {:call_id ""
                                                                           :content ""}})

require "http/client"

url = "{{baseUrl}}/v2/notes/:id.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "call_id=&content="

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v2/notes/:id.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "call_id", "" },
        { "content", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/notes/:id.json");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "call_id=&content=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/notes/:id.json"

	payload := strings.NewReader("call_id=&content=")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/v2/notes/:id.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 17

call_id=&content=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v2/notes/:id.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("call_id=&content=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/notes/:id.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("PUT", HttpRequest.BodyPublishers.ofString("call_id=&content="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "call_id=&content=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/notes/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v2/notes/:id.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("call_id=&content=")
  .asString();

const data = 'call_id=&content=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v2/notes/:id.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('call_id', '');
encodedParams.set('content', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/notes/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/notes/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({call_id: '', content: ''})
};

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}}/v2/notes/:id.json',
  method: 'PUT',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    call_id: '',
    content: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "call_id=&content=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/notes/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/notes/:id.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({call_id: '', content: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/notes/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {call_id: '', content: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/v2/notes/:id.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  call_id: '',
  content: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('call_id', '');
encodedParams.set('content', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/notes/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('call_id', '');
encodedParams.set('content', '');

const url = '{{baseUrl}}/v2/notes/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"call_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&content=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/notes/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/notes/:id.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "call_id=&content=" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/notes/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => "call_id=&content=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/v2/notes/:id.json', [
  'form_params' => [
    'call_id' => '',
    'content' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/notes/:id.json');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'call_id' => '',
  'content' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'call_id' => '',
  'content' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/notes/:id.json');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/notes/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'call_id=&content='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/notes/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'call_id=&content='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "call_id=&content="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PUT", "/baseUrl/v2/notes/:id.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/notes/:id.json"

payload = {
    "call_id": "",
    "content": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.put(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/notes/:id.json"

payload <- "call_id=&content="

encode <- "form"

response <- VERB("PUT", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/notes/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "call_id=&content="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :call_id => "",
  :content => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.put('/baseUrl/v2/notes/:id.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/notes/:id.json";

    let payload = json!({
        "call_id": "",
        "content": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/v2/notes/:id.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data call_id= \
  --data content=

http --form PUT {{baseUrl}}/v2/notes/:id.json \
  content-type:application/x-www-form-urlencoded \
  call_id='' \
  content=''

wget --quiet \
  --method PUT \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'call_id=&content=' \
  --output-document \
  - {{baseUrl}}/v2/notes/:id.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "call_id=".data(using: String.Encoding.utf8)!)
postData.append("&content=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/notes/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create an ongoing action

{{baseUrl}}/v2/ongoing_actions.json

BODY formUrlEncoded

action_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/ongoing_actions.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "action_id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/ongoing_actions.json" {:form-params {:action_id ""}})

require "http/client"

url = "{{baseUrl}}/v2/ongoing_actions.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "action_id="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/ongoing_actions.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "action_id", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/ongoing_actions.json");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "action_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/ongoing_actions.json"

	payload := strings.NewReader("action_id=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/ongoing_actions.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 10

action_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/ongoing_actions.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("action_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/ongoing_actions.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("action_id="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "action_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/ongoing_actions.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/ongoing_actions.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("action_id=")
  .asString();

const data = 'action_id=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/ongoing_actions.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('action_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/ongoing_actions.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/ongoing_actions.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({action_id: ''})
};

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}}/v2/ongoing_actions.json',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    action_id: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "action_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/ongoing_actions.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/ongoing_actions.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({action_id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/ongoing_actions.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {action_id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/ongoing_actions.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  action_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('action_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/ongoing_actions.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('action_id', '');

const url = '{{baseUrl}}/v2/ongoing_actions.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"action_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/ongoing_actions.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/ongoing_actions.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "action_id=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/ongoing_actions.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "action_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/ongoing_actions.json', [
  'form_params' => [
    'action_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/ongoing_actions.json');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'action_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'action_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/ongoing_actions.json');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/ongoing_actions.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'action_id='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/ongoing_actions.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'action_id='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "action_id="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/ongoing_actions.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/ongoing_actions.json"

payload = { "action_id": "" }
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/ongoing_actions.json"

payload <- "action_id="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/ongoing_actions.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "action_id="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :action_id => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/ongoing_actions.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/ongoing_actions.json";

    let payload = json!({"action_id": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/ongoing_actions.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data action_id=

http --form POST {{baseUrl}}/v2/ongoing_actions.json \
  content-type:application/x-www-form-urlencoded \
  action_id=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data action_id= \
  --output-document \
  - {{baseUrl}}/v2/ongoing_actions.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "action_id=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/ongoing_actions.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetches a list of emails ready to be sent by an external email service. Only emails sent with an External Email Client will appear here.

{{baseUrl}}/v2/pending_emails.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/pending_emails.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/pending_emails.json")

require "http/client"

url = "{{baseUrl}}/v2/pending_emails.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/pending_emails.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/pending_emails.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/pending_emails.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/pending_emails.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/pending_emails.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/pending_emails.json"))
    .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}}/v2/pending_emails.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/pending_emails.json")
  .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}}/v2/pending_emails.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/pending_emails.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/pending_emails.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/pending_emails.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/pending_emails.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/pending_emails.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/pending_emails.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/pending_emails.json');

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}}/v2/pending_emails.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/pending_emails.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/pending_emails.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/pending_emails.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/pending_emails.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/pending_emails.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/pending_emails.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/pending_emails.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/pending_emails.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/pending_emails.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/pending_emails.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/pending_emails.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/pending_emails.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/pending_emails.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/pending_emails.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/pending_emails.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/pending_emails.json

http GET {{baseUrl}}/v2/pending_emails.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/pending_emails.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/pending_emails.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT Updates the status of an email sent by an External Email Client

{{baseUrl}}/v2/pending_emails/:id.json

QUERY PARAMS

BODY formUrlEncoded

error_message

message_id

sent_at

status

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/pending_emails/:id.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "error_message=&message_id=&sent_at=&status=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v2/pending_emails/:id.json" {:form-params {:error_message ""
                                                                                    :message_id ""
                                                                                    :sent_at ""
                                                                                    :status ""}})

require "http/client"

url = "{{baseUrl}}/v2/pending_emails/:id.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "error_message=&message_id=&sent_at=&status="

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v2/pending_emails/:id.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "error_message", "" },
        { "message_id", "" },
        { "sent_at", "" },
        { "status", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/pending_emails/:id.json");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "error_message=&message_id=&sent_at=&status=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/pending_emails/:id.json"

	payload := strings.NewReader("error_message=&message_id=&sent_at=&status=")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/v2/pending_emails/:id.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 43

error_message=&message_id=&sent_at=&status=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v2/pending_emails/:id.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("error_message=&message_id=&sent_at=&status=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/pending_emails/:id.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("PUT", HttpRequest.BodyPublishers.ofString("error_message=&message_id=&sent_at=&status="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "error_message=&message_id=&sent_at=&status=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/pending_emails/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v2/pending_emails/:id.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("error_message=&message_id=&sent_at=&status=")
  .asString();

const data = 'error_message=&message_id=&sent_at=&status=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v2/pending_emails/:id.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('error_message', '');
encodedParams.set('message_id', '');
encodedParams.set('sent_at', '');
encodedParams.set('status', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/pending_emails/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/pending_emails/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({error_message: '', message_id: '', sent_at: '', status: ''})
};

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}}/v2/pending_emails/:id.json',
  method: 'PUT',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    error_message: '',
    message_id: '',
    sent_at: '',
    status: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "error_message=&message_id=&sent_at=&status=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/pending_emails/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/pending_emails/:id.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({error_message: '', message_id: '', sent_at: '', status: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/pending_emails/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {error_message: '', message_id: '', sent_at: '', status: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/v2/pending_emails/:id.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  error_message: '',
  message_id: '',
  sent_at: '',
  status: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('error_message', '');
encodedParams.set('message_id', '');
encodedParams.set('sent_at', '');
encodedParams.set('status', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/pending_emails/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('error_message', '');
encodedParams.set('message_id', '');
encodedParams.set('sent_at', '');
encodedParams.set('status', '');

const url = '{{baseUrl}}/v2/pending_emails/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"error_message=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&message_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&sent_at=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&status=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/pending_emails/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/pending_emails/:id.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "error_message=&message_id=&sent_at=&status=" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/pending_emails/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => "error_message=&message_id=&sent_at=&status=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/v2/pending_emails/:id.json', [
  'form_params' => [
    'error_message' => '',
    'message_id' => '',
    'sent_at' => '',
    'status' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/pending_emails/:id.json');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'error_message' => '',
  'message_id' => '',
  'sent_at' => '',
  'status' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'error_message' => '',
  'message_id' => '',
  'sent_at' => '',
  'status' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/pending_emails/:id.json');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/pending_emails/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'error_message=&message_id=&sent_at=&status='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/pending_emails/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'error_message=&message_id=&sent_at=&status='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "error_message=&message_id=&sent_at=&status="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PUT", "/baseUrl/v2/pending_emails/:id.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/pending_emails/:id.json"

payload = {
    "error_message": "",
    "message_id": "",
    "sent_at": "",
    "status": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.put(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/pending_emails/:id.json"

payload <- "error_message=&message_id=&sent_at=&status="

encode <- "form"

response <- VERB("PUT", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/pending_emails/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "error_message=&message_id=&sent_at=&status="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :error_message => "",
  :message_id => "",
  :sent_at => "",
  :status => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.put('/baseUrl/v2/pending_emails/:id.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/pending_emails/:id.json";

    let payload = json!({
        "error_message": "",
        "message_id": "",
        "sent_at": "",
        "status": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/v2/pending_emails/:id.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data error_message= \
  --data message_id= \
  --data sent_at= \
  --data status=

http --form PUT {{baseUrl}}/v2/pending_emails/:id.json \
  content-type:application/x-www-form-urlencoded \
  error_message='' \
  message_id='' \
  sent_at='' \
  status=''

wget --quiet \
  --method PUT \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'error_message=&message_id=&sent_at=&status=' \
  --output-document \
  - {{baseUrl}}/v2/pending_emails/:id.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "error_message=".data(using: String.Encoding.utf8)!)
postData.append("&message_id=".data(using: String.Encoding.utf8)!)
postData.append("&sent_at=".data(using: String.Encoding.utf8)!)
postData.append("&status=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/pending_emails/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create a person

{{baseUrl}}/v2/people.json

BODY formUrlEncoded

account_id

autotag_date

city

contact_restrictions

country

crm_id

crm_id_type

custom_fields

do_not_contact

email_address

first_name

home_phone

import_id

job_seniority

last_name

linkedin_url

locale

mobile_phone

owner_id

person_company_industry

person_company_name

person_company_website

person_stage_id

personal_email_address

personal_website

phone

phone_extension

secondary_email_address

state

tags

title

twitter_handle

work_city

work_country

work_state

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/people.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "account_id=&autotag_date=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/people.json" {:form-params {:account_id ""
                                                                         :autotag_date ""
                                                                         :city ""
                                                                         :contact_restrictions ""
                                                                         :country ""
                                                                         :crm_id ""
                                                                         :crm_id_type ""
                                                                         :custom_fields ""
                                                                         :do_not_contact ""
                                                                         :email_address ""
                                                                         :first_name ""
                                                                         :home_phone ""
                                                                         :import_id ""
                                                                         :job_seniority ""
                                                                         :last_name ""
                                                                         :linkedin_url ""
                                                                         :locale ""
                                                                         :mobile_phone ""
                                                                         :owner_id ""
                                                                         :person_company_industry ""
                                                                         :person_company_name ""
                                                                         :person_company_website ""
                                                                         :person_stage_id ""
                                                                         :personal_email_address ""
                                                                         :personal_website ""
                                                                         :phone ""
                                                                         :phone_extension ""
                                                                         :secondary_email_address ""
                                                                         :state ""
                                                                         :tags ""
                                                                         :title ""
                                                                         :twitter_handle ""
                                                                         :work_city ""
                                                                         :work_country ""
                                                                         :work_state ""}})

require "http/client"

url = "{{baseUrl}}/v2/people.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "account_id=&autotag_date=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/people.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "account_id", "" },
        { "autotag_date", "" },
        { "city", "" },
        { "contact_restrictions", "" },
        { "country", "" },
        { "crm_id", "" },
        { "crm_id_type", "" },
        { "custom_fields", "" },
        { "do_not_contact", "" },
        { "email_address", "" },
        { "first_name", "" },
        { "home_phone", "" },
        { "import_id", "" },
        { "job_seniority", "" },
        { "last_name", "" },
        { "linkedin_url", "" },
        { "locale", "" },
        { "mobile_phone", "" },
        { "owner_id", "" },
        { "person_company_industry", "" },
        { "person_company_name", "" },
        { "person_company_website", "" },
        { "person_stage_id", "" },
        { "personal_email_address", "" },
        { "personal_website", "" },
        { "phone", "" },
        { "phone_extension", "" },
        { "secondary_email_address", "" },
        { "state", "" },
        { "tags", "" },
        { "title", "" },
        { "twitter_handle", "" },
        { "work_city", "" },
        { "work_country", "" },
        { "work_state", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/people.json");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "account_id=&autotag_date=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/people.json"

	payload := strings.NewReader("account_id=&autotag_date=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/people.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 487

account_id=&autotag_date=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/people.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("account_id=&autotag_date=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/people.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("account_id=&autotag_date=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "account_id=&autotag_date=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/people.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/people.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("account_id=&autotag_date=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=")
  .asString();

const data = 'account_id=&autotag_date=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/people.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('account_id', '');
encodedParams.set('autotag_date', '');
encodedParams.set('city', '');
encodedParams.set('contact_restrictions', '');
encodedParams.set('country', '');
encodedParams.set('crm_id', '');
encodedParams.set('crm_id_type', '');
encodedParams.set('custom_fields', '');
encodedParams.set('do_not_contact', '');
encodedParams.set('email_address', '');
encodedParams.set('first_name', '');
encodedParams.set('home_phone', '');
encodedParams.set('import_id', '');
encodedParams.set('job_seniority', '');
encodedParams.set('last_name', '');
encodedParams.set('linkedin_url', '');
encodedParams.set('locale', '');
encodedParams.set('mobile_phone', '');
encodedParams.set('owner_id', '');
encodedParams.set('person_company_industry', '');
encodedParams.set('person_company_name', '');
encodedParams.set('person_company_website', '');
encodedParams.set('person_stage_id', '');
encodedParams.set('personal_email_address', '');
encodedParams.set('personal_website', '');
encodedParams.set('phone', '');
encodedParams.set('phone_extension', '');
encodedParams.set('secondary_email_address', '');
encodedParams.set('state', '');
encodedParams.set('tags', '');
encodedParams.set('title', '');
encodedParams.set('twitter_handle', '');
encodedParams.set('work_city', '');
encodedParams.set('work_country', '');
encodedParams.set('work_state', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/people.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/people.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    account_id: '',
    autotag_date: '',
    city: '',
    contact_restrictions: '',
    country: '',
    crm_id: '',
    crm_id_type: '',
    custom_fields: '',
    do_not_contact: '',
    email_address: '',
    first_name: '',
    home_phone: '',
    import_id: '',
    job_seniority: '',
    last_name: '',
    linkedin_url: '',
    locale: '',
    mobile_phone: '',
    owner_id: '',
    person_company_industry: '',
    person_company_name: '',
    person_company_website: '',
    person_stage_id: '',
    personal_email_address: '',
    personal_website: '',
    phone: '',
    phone_extension: '',
    secondary_email_address: '',
    state: '',
    tags: '',
    title: '',
    twitter_handle: '',
    work_city: '',
    work_country: '',
    work_state: ''
  })
};

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}}/v2/people.json',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    account_id: '',
    autotag_date: '',
    city: '',
    contact_restrictions: '',
    country: '',
    crm_id: '',
    crm_id_type: '',
    custom_fields: '',
    do_not_contact: '',
    email_address: '',
    first_name: '',
    home_phone: '',
    import_id: '',
    job_seniority: '',
    last_name: '',
    linkedin_url: '',
    locale: '',
    mobile_phone: '',
    owner_id: '',
    person_company_industry: '',
    person_company_name: '',
    person_company_website: '',
    person_stage_id: '',
    personal_email_address: '',
    personal_website: '',
    phone: '',
    phone_extension: '',
    secondary_email_address: '',
    state: '',
    tags: '',
    title: '',
    twitter_handle: '',
    work_city: '',
    work_country: '',
    work_state: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "account_id=&autotag_date=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/people.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/people.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({
  account_id: '',
  autotag_date: '',
  city: '',
  contact_restrictions: '',
  country: '',
  crm_id: '',
  crm_id_type: '',
  custom_fields: '',
  do_not_contact: '',
  email_address: '',
  first_name: '',
  home_phone: '',
  import_id: '',
  job_seniority: '',
  last_name: '',
  linkedin_url: '',
  locale: '',
  mobile_phone: '',
  owner_id: '',
  person_company_industry: '',
  person_company_name: '',
  person_company_website: '',
  person_stage_id: '',
  personal_email_address: '',
  personal_website: '',
  phone: '',
  phone_extension: '',
  secondary_email_address: '',
  state: '',
  tags: '',
  title: '',
  twitter_handle: '',
  work_city: '',
  work_country: '',
  work_state: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/people.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    account_id: '',
    autotag_date: '',
    city: '',
    contact_restrictions: '',
    country: '',
    crm_id: '',
    crm_id_type: '',
    custom_fields: '',
    do_not_contact: '',
    email_address: '',
    first_name: '',
    home_phone: '',
    import_id: '',
    job_seniority: '',
    last_name: '',
    linkedin_url: '',
    locale: '',
    mobile_phone: '',
    owner_id: '',
    person_company_industry: '',
    person_company_name: '',
    person_company_website: '',
    person_stage_id: '',
    personal_email_address: '',
    personal_website: '',
    phone: '',
    phone_extension: '',
    secondary_email_address: '',
    state: '',
    tags: '',
    title: '',
    twitter_handle: '',
    work_city: '',
    work_country: '',
    work_state: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/people.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  account_id: '',
  autotag_date: '',
  city: '',
  contact_restrictions: '',
  country: '',
  crm_id: '',
  crm_id_type: '',
  custom_fields: '',
  do_not_contact: '',
  email_address: '',
  first_name: '',
  home_phone: '',
  import_id: '',
  job_seniority: '',
  last_name: '',
  linkedin_url: '',
  locale: '',
  mobile_phone: '',
  owner_id: '',
  person_company_industry: '',
  person_company_name: '',
  person_company_website: '',
  person_stage_id: '',
  personal_email_address: '',
  personal_website: '',
  phone: '',
  phone_extension: '',
  secondary_email_address: '',
  state: '',
  tags: '',
  title: '',
  twitter_handle: '',
  work_city: '',
  work_country: '',
  work_state: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('account_id', '');
encodedParams.set('autotag_date', '');
encodedParams.set('city', '');
encodedParams.set('contact_restrictions', '');
encodedParams.set('country', '');
encodedParams.set('crm_id', '');
encodedParams.set('crm_id_type', '');
encodedParams.set('custom_fields', '');
encodedParams.set('do_not_contact', '');
encodedParams.set('email_address', '');
encodedParams.set('first_name', '');
encodedParams.set('home_phone', '');
encodedParams.set('import_id', '');
encodedParams.set('job_seniority', '');
encodedParams.set('last_name', '');
encodedParams.set('linkedin_url', '');
encodedParams.set('locale', '');
encodedParams.set('mobile_phone', '');
encodedParams.set('owner_id', '');
encodedParams.set('person_company_industry', '');
encodedParams.set('person_company_name', '');
encodedParams.set('person_company_website', '');
encodedParams.set('person_stage_id', '');
encodedParams.set('personal_email_address', '');
encodedParams.set('personal_website', '');
encodedParams.set('phone', '');
encodedParams.set('phone_extension', '');
encodedParams.set('secondary_email_address', '');
encodedParams.set('state', '');
encodedParams.set('tags', '');
encodedParams.set('title', '');
encodedParams.set('twitter_handle', '');
encodedParams.set('work_city', '');
encodedParams.set('work_country', '');
encodedParams.set('work_state', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/people.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('account_id', '');
encodedParams.set('autotag_date', '');
encodedParams.set('city', '');
encodedParams.set('contact_restrictions', '');
encodedParams.set('country', '');
encodedParams.set('crm_id', '');
encodedParams.set('crm_id_type', '');
encodedParams.set('custom_fields', '');
encodedParams.set('do_not_contact', '');
encodedParams.set('email_address', '');
encodedParams.set('first_name', '');
encodedParams.set('home_phone', '');
encodedParams.set('import_id', '');
encodedParams.set('job_seniority', '');
encodedParams.set('last_name', '');
encodedParams.set('linkedin_url', '');
encodedParams.set('locale', '');
encodedParams.set('mobile_phone', '');
encodedParams.set('owner_id', '');
encodedParams.set('person_company_industry', '');
encodedParams.set('person_company_name', '');
encodedParams.set('person_company_website', '');
encodedParams.set('person_stage_id', '');
encodedParams.set('personal_email_address', '');
encodedParams.set('personal_website', '');
encodedParams.set('phone', '');
encodedParams.set('phone_extension', '');
encodedParams.set('secondary_email_address', '');
encodedParams.set('state', '');
encodedParams.set('tags', '');
encodedParams.set('title', '');
encodedParams.set('twitter_handle', '');
encodedParams.set('work_city', '');
encodedParams.set('work_country', '');
encodedParams.set('work_state', '');

const url = '{{baseUrl}}/v2/people.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"account_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&autotag_date=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&city=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&contact_restrictions=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&country=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&crm_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&crm_id_type=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&custom_fields=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&do_not_contact=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&email_address=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&first_name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&home_phone=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&import_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&job_seniority=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&last_name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&linkedin_url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&locale=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&mobile_phone=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&owner_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&person_company_industry=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&person_company_name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&person_company_website=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&person_stage_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&personal_email_address=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&personal_website=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&phone=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&phone_extension=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&secondary_email_address=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&state=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&tags=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&title=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&twitter_handle=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&work_city=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&work_country=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&work_state=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/people.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/people.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "account_id=&autotag_date=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/people.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "account_id=&autotag_date=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/people.json', [
  'form_params' => [
    'account_id' => '',
    'autotag_date' => '',
    'city' => '',
    'contact_restrictions' => '',
    'country' => '',
    'crm_id' => '',
    'crm_id_type' => '',
    'custom_fields' => '',
    'do_not_contact' => '',
    'email_address' => '',
    'first_name' => '',
    'home_phone' => '',
    'import_id' => '',
    'job_seniority' => '',
    'last_name' => '',
    'linkedin_url' => '',
    'locale' => '',
    'mobile_phone' => '',
    'owner_id' => '',
    'person_company_industry' => '',
    'person_company_name' => '',
    'person_company_website' => '',
    'person_stage_id' => '',
    'personal_email_address' => '',
    'personal_website' => '',
    'phone' => '',
    'phone_extension' => '',
    'secondary_email_address' => '',
    'state' => '',
    'tags' => '',
    'title' => '',
    'twitter_handle' => '',
    'work_city' => '',
    'work_country' => '',
    'work_state' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/people.json');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'account_id' => '',
  'autotag_date' => '',
  'city' => '',
  'contact_restrictions' => '',
  'country' => '',
  'crm_id' => '',
  'crm_id_type' => '',
  'custom_fields' => '',
  'do_not_contact' => '',
  'email_address' => '',
  'first_name' => '',
  'home_phone' => '',
  'import_id' => '',
  'job_seniority' => '',
  'last_name' => '',
  'linkedin_url' => '',
  'locale' => '',
  'mobile_phone' => '',
  'owner_id' => '',
  'person_company_industry' => '',
  'person_company_name' => '',
  'person_company_website' => '',
  'person_stage_id' => '',
  'personal_email_address' => '',
  'personal_website' => '',
  'phone' => '',
  'phone_extension' => '',
  'secondary_email_address' => '',
  'state' => '',
  'tags' => '',
  'title' => '',
  'twitter_handle' => '',
  'work_city' => '',
  'work_country' => '',
  'work_state' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'account_id' => '',
  'autotag_date' => '',
  'city' => '',
  'contact_restrictions' => '',
  'country' => '',
  'crm_id' => '',
  'crm_id_type' => '',
  'custom_fields' => '',
  'do_not_contact' => '',
  'email_address' => '',
  'first_name' => '',
  'home_phone' => '',
  'import_id' => '',
  'job_seniority' => '',
  'last_name' => '',
  'linkedin_url' => '',
  'locale' => '',
  'mobile_phone' => '',
  'owner_id' => '',
  'person_company_industry' => '',
  'person_company_name' => '',
  'person_company_website' => '',
  'person_stage_id' => '',
  'personal_email_address' => '',
  'personal_website' => '',
  'phone' => '',
  'phone_extension' => '',
  'secondary_email_address' => '',
  'state' => '',
  'tags' => '',
  'title' => '',
  'twitter_handle' => '',
  'work_city' => '',
  'work_country' => '',
  'work_state' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/people.json');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/people.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'account_id=&autotag_date=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/people.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'account_id=&autotag_date=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "account_id=&autotag_date=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/people.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/people.json"

payload = {
    "account_id": "",
    "autotag_date": "",
    "city": "",
    "contact_restrictions": "",
    "country": "",
    "crm_id": "",
    "crm_id_type": "",
    "custom_fields": "",
    "do_not_contact": "",
    "email_address": "",
    "first_name": "",
    "home_phone": "",
    "import_id": "",
    "job_seniority": "",
    "last_name": "",
    "linkedin_url": "",
    "locale": "",
    "mobile_phone": "",
    "owner_id": "",
    "person_company_industry": "",
    "person_company_name": "",
    "person_company_website": "",
    "person_stage_id": "",
    "personal_email_address": "",
    "personal_website": "",
    "phone": "",
    "phone_extension": "",
    "secondary_email_address": "",
    "state": "",
    "tags": "",
    "title": "",
    "twitter_handle": "",
    "work_city": "",
    "work_country": "",
    "work_state": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/people.json"

payload <- "account_id=&autotag_date=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/people.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "account_id=&autotag_date=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :account_id => "",
  :autotag_date => "",
  :city => "",
  :contact_restrictions => "",
  :country => "",
  :crm_id => "",
  :crm_id_type => "",
  :custom_fields => "",
  :do_not_contact => "",
  :email_address => "",
  :first_name => "",
  :home_phone => "",
  :import_id => "",
  :job_seniority => "",
  :last_name => "",
  :linkedin_url => "",
  :locale => "",
  :mobile_phone => "",
  :owner_id => "",
  :person_company_industry => "",
  :person_company_name => "",
  :person_company_website => "",
  :person_stage_id => "",
  :personal_email_address => "",
  :personal_website => "",
  :phone => "",
  :phone_extension => "",
  :secondary_email_address => "",
  :state => "",
  :tags => "",
  :title => "",
  :twitter_handle => "",
  :work_city => "",
  :work_country => "",
  :work_state => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/people.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/people.json";

    let payload = json!({
        "account_id": "",
        "autotag_date": "",
        "city": "",
        "contact_restrictions": "",
        "country": "",
        "crm_id": "",
        "crm_id_type": "",
        "custom_fields": "",
        "do_not_contact": "",
        "email_address": "",
        "first_name": "",
        "home_phone": "",
        "import_id": "",
        "job_seniority": "",
        "last_name": "",
        "linkedin_url": "",
        "locale": "",
        "mobile_phone": "",
        "owner_id": "",
        "person_company_industry": "",
        "person_company_name": "",
        "person_company_website": "",
        "person_stage_id": "",
        "personal_email_address": "",
        "personal_website": "",
        "phone": "",
        "phone_extension": "",
        "secondary_email_address": "",
        "state": "",
        "tags": "",
        "title": "",
        "twitter_handle": "",
        "work_city": "",
        "work_country": "",
        "work_state": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/people.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data account_id= \
  --data autotag_date= \
  --data city= \
  --data contact_restrictions= \
  --data country= \
  --data crm_id= \
  --data crm_id_type= \
  --data custom_fields= \
  --data do_not_contact= \
  --data email_address= \
  --data first_name= \
  --data home_phone= \
  --data import_id= \
  --data job_seniority= \
  --data last_name= \
  --data linkedin_url= \
  --data locale= \
  --data mobile_phone= \
  --data owner_id= \
  --data person_company_industry= \
  --data person_company_name= \
  --data person_company_website= \
  --data person_stage_id= \
  --data personal_email_address= \
  --data personal_website= \
  --data phone= \
  --data phone_extension= \
  --data secondary_email_address= \
  --data state= \
  --data tags= \
  --data title= \
  --data twitter_handle= \
  --data work_city= \
  --data work_country= \
  --data work_state=

http --form POST {{baseUrl}}/v2/people.json \
  content-type:application/x-www-form-urlencoded \
  account_id='' \
  autotag_date='' \
  city='' \
  contact_restrictions='' \
  country='' \
  crm_id='' \
  crm_id_type='' \
  custom_fields='' \
  do_not_contact='' \
  email_address='' \
  first_name='' \
  home_phone='' \
  import_id='' \
  job_seniority='' \
  last_name='' \
  linkedin_url='' \
  locale='' \
  mobile_phone='' \
  owner_id='' \
  person_company_industry='' \
  person_company_name='' \
  person_company_website='' \
  person_stage_id='' \
  personal_email_address='' \
  personal_website='' \
  phone='' \
  phone_extension='' \
  secondary_email_address='' \
  state='' \
  tags='' \
  title='' \
  twitter_handle='' \
  work_city='' \
  work_country='' \
  work_state=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'account_id=&autotag_date=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=' \
  --output-document \
  - {{baseUrl}}/v2/people.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "account_id=".data(using: String.Encoding.utf8)!)
postData.append("&autotag_date=".data(using: String.Encoding.utf8)!)
postData.append("&city=".data(using: String.Encoding.utf8)!)
postData.append("&contact_restrictions=".data(using: String.Encoding.utf8)!)
postData.append("&country=".data(using: String.Encoding.utf8)!)
postData.append("&crm_id=".data(using: String.Encoding.utf8)!)
postData.append("&crm_id_type=".data(using: String.Encoding.utf8)!)
postData.append("&custom_fields=".data(using: String.Encoding.utf8)!)
postData.append("&do_not_contact=".data(using: String.Encoding.utf8)!)
postData.append("&email_address=".data(using: String.Encoding.utf8)!)
postData.append("&first_name=".data(using: String.Encoding.utf8)!)
postData.append("&home_phone=".data(using: String.Encoding.utf8)!)
postData.append("&import_id=".data(using: String.Encoding.utf8)!)
postData.append("&job_seniority=".data(using: String.Encoding.utf8)!)
postData.append("&last_name=".data(using: String.Encoding.utf8)!)
postData.append("&linkedin_url=".data(using: String.Encoding.utf8)!)
postData.append("&locale=".data(using: String.Encoding.utf8)!)
postData.append("&mobile_phone=".data(using: String.Encoding.utf8)!)
postData.append("&owner_id=".data(using: String.Encoding.utf8)!)
postData.append("&person_company_industry=".data(using: String.Encoding.utf8)!)
postData.append("&person_company_name=".data(using: String.Encoding.utf8)!)
postData.append("&person_company_website=".data(using: String.Encoding.utf8)!)
postData.append("&person_stage_id=".data(using: String.Encoding.utf8)!)
postData.append("&personal_email_address=".data(using: String.Encoding.utf8)!)
postData.append("&personal_website=".data(using: String.Encoding.utf8)!)
postData.append("&phone=".data(using: String.Encoding.utf8)!)
postData.append("&phone_extension=".data(using: String.Encoding.utf8)!)
postData.append("&secondary_email_address=".data(using: String.Encoding.utf8)!)
postData.append("&state=".data(using: String.Encoding.utf8)!)
postData.append("&tags=".data(using: String.Encoding.utf8)!)
postData.append("&title=".data(using: String.Encoding.utf8)!)
postData.append("&twitter_handle=".data(using: String.Encoding.utf8)!)
postData.append("&work_city=".data(using: String.Encoding.utf8)!)
postData.append("&work_country=".data(using: String.Encoding.utf8)!)
postData.append("&work_state=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/people.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Delete a person

{{baseUrl}}/v2/people/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/people/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v2/people/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/people/:id.json"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v2/people/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/people/:id.json");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/people/:id.json"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v2/people/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/people/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/people/:id.json"))
    .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}}/v2/people/:id.json")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v2/people/:id.json")
  .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}}/v2/people/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v2/people/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/people/:id.json';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/people/:id.json',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/people/:id.json")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/people/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/v2/people/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/people/:id.json');

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}}/v2/people/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/people/:id.json';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/people/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/people/:id.json" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/people/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v2/people/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/people/:id.json');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/people/:id.json');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/people/:id.json' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/people/:id.json' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v2/people/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/people/:id.json"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/people/:id.json"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/people/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v2/people/:id.json') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/people/:id.json";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v2/people/:id.json

http DELETE {{baseUrl}}/v2/people/:id.json

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/people/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/people/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch a person

{{baseUrl}}/v2/people/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/people/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/people/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/people/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/people/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/people/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/people/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/people/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/people/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/people/:id.json"))
    .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}}/v2/people/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/people/:id.json")
  .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}}/v2/people/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/people/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/people/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/people/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/people/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/people/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/people/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/people/:id.json');

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}}/v2/people/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/people/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/people/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/people/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/people/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/people/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/people/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/people/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/people/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/people/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/people/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/people/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/people/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/people/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/people/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/people/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/people/:id.json

http GET {{baseUrl}}/v2/people/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/people/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/people/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List people

{{baseUrl}}/v2/people.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/people.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/people.json")

require "http/client"

url = "{{baseUrl}}/v2/people.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/people.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/people.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/people.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/people.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/people.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/people.json"))
    .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}}/v2/people.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/people.json")
  .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}}/v2/people.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/people.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/people.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/people.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/people.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/people.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/people.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/people.json');

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}}/v2/people.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/people.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/people.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/people.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/people.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/people.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/people.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/people.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/people.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/people.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/people.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/people.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/people.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/people.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/people.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/people.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/people.json

http GET {{baseUrl}}/v2/people.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/people.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/people.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT Update a person

{{baseUrl}}/v2/people/:id.json

QUERY PARAMS

BODY formUrlEncoded

account_id

city

contact_restrictions

country

crm_id

crm_id_type

custom_fields

do_not_contact

email_address

first_name

home_phone

import_id

job_seniority

last_name

linkedin_url

locale

mobile_phone

owner_id

person_company_industry

person_company_name

person_company_website

person_stage_id

personal_email_address

personal_website

phone

phone_extension

secondary_email_address

state

tags

title

twitter_handle

work_city

work_country

work_state

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/people/:id.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v2/people/:id.json" {:form-params {:account_id ""
                                                                            :city ""
                                                                            :contact_restrictions ""
                                                                            :country ""
                                                                            :crm_id ""
                                                                            :crm_id_type ""
                                                                            :custom_fields ""
                                                                            :do_not_contact ""
                                                                            :email_address ""
                                                                            :first_name ""
                                                                            :home_phone ""
                                                                            :import_id ""
                                                                            :job_seniority ""
                                                                            :last_name ""
                                                                            :linkedin_url ""
                                                                            :locale ""
                                                                            :mobile_phone ""
                                                                            :owner_id ""
                                                                            :person_company_industry ""
                                                                            :person_company_name ""
                                                                            :person_company_website ""
                                                                            :person_stage_id ""
                                                                            :personal_email_address ""
                                                                            :personal_website ""
                                                                            :phone ""
                                                                            :phone_extension ""
                                                                            :secondary_email_address ""
                                                                            :state ""
                                                                            :tags ""
                                                                            :title ""
                                                                            :twitter_handle ""
                                                                            :work_city ""
                                                                            :work_country ""
                                                                            :work_state ""}})

require "http/client"

url = "{{baseUrl}}/v2/people/:id.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state="

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v2/people/:id.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "account_id", "" },
        { "city", "" },
        { "contact_restrictions", "" },
        { "country", "" },
        { "crm_id", "" },
        { "crm_id_type", "" },
        { "custom_fields", "" },
        { "do_not_contact", "" },
        { "email_address", "" },
        { "first_name", "" },
        { "home_phone", "" },
        { "import_id", "" },
        { "job_seniority", "" },
        { "last_name", "" },
        { "linkedin_url", "" },
        { "locale", "" },
        { "mobile_phone", "" },
        { "owner_id", "" },
        { "person_company_industry", "" },
        { "person_company_name", "" },
        { "person_company_website", "" },
        { "person_stage_id", "" },
        { "personal_email_address", "" },
        { "personal_website", "" },
        { "phone", "" },
        { "phone_extension", "" },
        { "secondary_email_address", "" },
        { "state", "" },
        { "tags", "" },
        { "title", "" },
        { "twitter_handle", "" },
        { "work_city", "" },
        { "work_country", "" },
        { "work_state", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/people/:id.json");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/people/:id.json"

	payload := strings.NewReader("account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/v2/people/:id.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 473

account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v2/people/:id.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/people/:id.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("PUT", HttpRequest.BodyPublishers.ofString("account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/people/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v2/people/:id.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=")
  .asString();

const data = 'account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v2/people/:id.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('account_id', '');
encodedParams.set('city', '');
encodedParams.set('contact_restrictions', '');
encodedParams.set('country', '');
encodedParams.set('crm_id', '');
encodedParams.set('crm_id_type', '');
encodedParams.set('custom_fields', '');
encodedParams.set('do_not_contact', '');
encodedParams.set('email_address', '');
encodedParams.set('first_name', '');
encodedParams.set('home_phone', '');
encodedParams.set('import_id', '');
encodedParams.set('job_seniority', '');
encodedParams.set('last_name', '');
encodedParams.set('linkedin_url', '');
encodedParams.set('locale', '');
encodedParams.set('mobile_phone', '');
encodedParams.set('owner_id', '');
encodedParams.set('person_company_industry', '');
encodedParams.set('person_company_name', '');
encodedParams.set('person_company_website', '');
encodedParams.set('person_stage_id', '');
encodedParams.set('personal_email_address', '');
encodedParams.set('personal_website', '');
encodedParams.set('phone', '');
encodedParams.set('phone_extension', '');
encodedParams.set('secondary_email_address', '');
encodedParams.set('state', '');
encodedParams.set('tags', '');
encodedParams.set('title', '');
encodedParams.set('twitter_handle', '');
encodedParams.set('work_city', '');
encodedParams.set('work_country', '');
encodedParams.set('work_state', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/people/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/people/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    account_id: '',
    city: '',
    contact_restrictions: '',
    country: '',
    crm_id: '',
    crm_id_type: '',
    custom_fields: '',
    do_not_contact: '',
    email_address: '',
    first_name: '',
    home_phone: '',
    import_id: '',
    job_seniority: '',
    last_name: '',
    linkedin_url: '',
    locale: '',
    mobile_phone: '',
    owner_id: '',
    person_company_industry: '',
    person_company_name: '',
    person_company_website: '',
    person_stage_id: '',
    personal_email_address: '',
    personal_website: '',
    phone: '',
    phone_extension: '',
    secondary_email_address: '',
    state: '',
    tags: '',
    title: '',
    twitter_handle: '',
    work_city: '',
    work_country: '',
    work_state: ''
  })
};

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}}/v2/people/:id.json',
  method: 'PUT',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    account_id: '',
    city: '',
    contact_restrictions: '',
    country: '',
    crm_id: '',
    crm_id_type: '',
    custom_fields: '',
    do_not_contact: '',
    email_address: '',
    first_name: '',
    home_phone: '',
    import_id: '',
    job_seniority: '',
    last_name: '',
    linkedin_url: '',
    locale: '',
    mobile_phone: '',
    owner_id: '',
    person_company_industry: '',
    person_company_name: '',
    person_company_website: '',
    person_stage_id: '',
    personal_email_address: '',
    personal_website: '',
    phone: '',
    phone_extension: '',
    secondary_email_address: '',
    state: '',
    tags: '',
    title: '',
    twitter_handle: '',
    work_city: '',
    work_country: '',
    work_state: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/people/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/people/:id.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({
  account_id: '',
  city: '',
  contact_restrictions: '',
  country: '',
  crm_id: '',
  crm_id_type: '',
  custom_fields: '',
  do_not_contact: '',
  email_address: '',
  first_name: '',
  home_phone: '',
  import_id: '',
  job_seniority: '',
  last_name: '',
  linkedin_url: '',
  locale: '',
  mobile_phone: '',
  owner_id: '',
  person_company_industry: '',
  person_company_name: '',
  person_company_website: '',
  person_stage_id: '',
  personal_email_address: '',
  personal_website: '',
  phone: '',
  phone_extension: '',
  secondary_email_address: '',
  state: '',
  tags: '',
  title: '',
  twitter_handle: '',
  work_city: '',
  work_country: '',
  work_state: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/people/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    account_id: '',
    city: '',
    contact_restrictions: '',
    country: '',
    crm_id: '',
    crm_id_type: '',
    custom_fields: '',
    do_not_contact: '',
    email_address: '',
    first_name: '',
    home_phone: '',
    import_id: '',
    job_seniority: '',
    last_name: '',
    linkedin_url: '',
    locale: '',
    mobile_phone: '',
    owner_id: '',
    person_company_industry: '',
    person_company_name: '',
    person_company_website: '',
    person_stage_id: '',
    personal_email_address: '',
    personal_website: '',
    phone: '',
    phone_extension: '',
    secondary_email_address: '',
    state: '',
    tags: '',
    title: '',
    twitter_handle: '',
    work_city: '',
    work_country: '',
    work_state: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/v2/people/:id.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  account_id: '',
  city: '',
  contact_restrictions: '',
  country: '',
  crm_id: '',
  crm_id_type: '',
  custom_fields: '',
  do_not_contact: '',
  email_address: '',
  first_name: '',
  home_phone: '',
  import_id: '',
  job_seniority: '',
  last_name: '',
  linkedin_url: '',
  locale: '',
  mobile_phone: '',
  owner_id: '',
  person_company_industry: '',
  person_company_name: '',
  person_company_website: '',
  person_stage_id: '',
  personal_email_address: '',
  personal_website: '',
  phone: '',
  phone_extension: '',
  secondary_email_address: '',
  state: '',
  tags: '',
  title: '',
  twitter_handle: '',
  work_city: '',
  work_country: '',
  work_state: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('account_id', '');
encodedParams.set('city', '');
encodedParams.set('contact_restrictions', '');
encodedParams.set('country', '');
encodedParams.set('crm_id', '');
encodedParams.set('crm_id_type', '');
encodedParams.set('custom_fields', '');
encodedParams.set('do_not_contact', '');
encodedParams.set('email_address', '');
encodedParams.set('first_name', '');
encodedParams.set('home_phone', '');
encodedParams.set('import_id', '');
encodedParams.set('job_seniority', '');
encodedParams.set('last_name', '');
encodedParams.set('linkedin_url', '');
encodedParams.set('locale', '');
encodedParams.set('mobile_phone', '');
encodedParams.set('owner_id', '');
encodedParams.set('person_company_industry', '');
encodedParams.set('person_company_name', '');
encodedParams.set('person_company_website', '');
encodedParams.set('person_stage_id', '');
encodedParams.set('personal_email_address', '');
encodedParams.set('personal_website', '');
encodedParams.set('phone', '');
encodedParams.set('phone_extension', '');
encodedParams.set('secondary_email_address', '');
encodedParams.set('state', '');
encodedParams.set('tags', '');
encodedParams.set('title', '');
encodedParams.set('twitter_handle', '');
encodedParams.set('work_city', '');
encodedParams.set('work_country', '');
encodedParams.set('work_state', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/people/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('account_id', '');
encodedParams.set('city', '');
encodedParams.set('contact_restrictions', '');
encodedParams.set('country', '');
encodedParams.set('crm_id', '');
encodedParams.set('crm_id_type', '');
encodedParams.set('custom_fields', '');
encodedParams.set('do_not_contact', '');
encodedParams.set('email_address', '');
encodedParams.set('first_name', '');
encodedParams.set('home_phone', '');
encodedParams.set('import_id', '');
encodedParams.set('job_seniority', '');
encodedParams.set('last_name', '');
encodedParams.set('linkedin_url', '');
encodedParams.set('locale', '');
encodedParams.set('mobile_phone', '');
encodedParams.set('owner_id', '');
encodedParams.set('person_company_industry', '');
encodedParams.set('person_company_name', '');
encodedParams.set('person_company_website', '');
encodedParams.set('person_stage_id', '');
encodedParams.set('personal_email_address', '');
encodedParams.set('personal_website', '');
encodedParams.set('phone', '');
encodedParams.set('phone_extension', '');
encodedParams.set('secondary_email_address', '');
encodedParams.set('state', '');
encodedParams.set('tags', '');
encodedParams.set('title', '');
encodedParams.set('twitter_handle', '');
encodedParams.set('work_city', '');
encodedParams.set('work_country', '');
encodedParams.set('work_state', '');

const url = '{{baseUrl}}/v2/people/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"account_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&city=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&contact_restrictions=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&country=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&crm_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&crm_id_type=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&custom_fields=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&do_not_contact=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&email_address=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&first_name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&home_phone=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&import_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&job_seniority=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&last_name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&linkedin_url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&locale=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&mobile_phone=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&owner_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&person_company_industry=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&person_company_name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&person_company_website=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&person_stage_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&personal_email_address=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&personal_website=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&phone=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&phone_extension=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&secondary_email_address=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&state=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&tags=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&title=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&twitter_handle=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&work_city=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&work_country=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&work_state=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/people/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/people/:id.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/people/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => "account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/v2/people/:id.json', [
  'form_params' => [
    'account_id' => '',
    'city' => '',
    'contact_restrictions' => '',
    'country' => '',
    'crm_id' => '',
    'crm_id_type' => '',
    'custom_fields' => '',
    'do_not_contact' => '',
    'email_address' => '',
    'first_name' => '',
    'home_phone' => '',
    'import_id' => '',
    'job_seniority' => '',
    'last_name' => '',
    'linkedin_url' => '',
    'locale' => '',
    'mobile_phone' => '',
    'owner_id' => '',
    'person_company_industry' => '',
    'person_company_name' => '',
    'person_company_website' => '',
    'person_stage_id' => '',
    'personal_email_address' => '',
    'personal_website' => '',
    'phone' => '',
    'phone_extension' => '',
    'secondary_email_address' => '',
    'state' => '',
    'tags' => '',
    'title' => '',
    'twitter_handle' => '',
    'work_city' => '',
    'work_country' => '',
    'work_state' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/people/:id.json');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'account_id' => '',
  'city' => '',
  'contact_restrictions' => '',
  'country' => '',
  'crm_id' => '',
  'crm_id_type' => '',
  'custom_fields' => '',
  'do_not_contact' => '',
  'email_address' => '',
  'first_name' => '',
  'home_phone' => '',
  'import_id' => '',
  'job_seniority' => '',
  'last_name' => '',
  'linkedin_url' => '',
  'locale' => '',
  'mobile_phone' => '',
  'owner_id' => '',
  'person_company_industry' => '',
  'person_company_name' => '',
  'person_company_website' => '',
  'person_stage_id' => '',
  'personal_email_address' => '',
  'personal_website' => '',
  'phone' => '',
  'phone_extension' => '',
  'secondary_email_address' => '',
  'state' => '',
  'tags' => '',
  'title' => '',
  'twitter_handle' => '',
  'work_city' => '',
  'work_country' => '',
  'work_state' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'account_id' => '',
  'city' => '',
  'contact_restrictions' => '',
  'country' => '',
  'crm_id' => '',
  'crm_id_type' => '',
  'custom_fields' => '',
  'do_not_contact' => '',
  'email_address' => '',
  'first_name' => '',
  'home_phone' => '',
  'import_id' => '',
  'job_seniority' => '',
  'last_name' => '',
  'linkedin_url' => '',
  'locale' => '',
  'mobile_phone' => '',
  'owner_id' => '',
  'person_company_industry' => '',
  'person_company_name' => '',
  'person_company_website' => '',
  'person_stage_id' => '',
  'personal_email_address' => '',
  'personal_website' => '',
  'phone' => '',
  'phone_extension' => '',
  'secondary_email_address' => '',
  'state' => '',
  'tags' => '',
  'title' => '',
  'twitter_handle' => '',
  'work_city' => '',
  'work_country' => '',
  'work_state' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/people/:id.json');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/people/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/people/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PUT", "/baseUrl/v2/people/:id.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/people/:id.json"

payload = {
    "account_id": "",
    "city": "",
    "contact_restrictions": "",
    "country": "",
    "crm_id": "",
    "crm_id_type": "",
    "custom_fields": "",
    "do_not_contact": "",
    "email_address": "",
    "first_name": "",
    "home_phone": "",
    "import_id": "",
    "job_seniority": "",
    "last_name": "",
    "linkedin_url": "",
    "locale": "",
    "mobile_phone": "",
    "owner_id": "",
    "person_company_industry": "",
    "person_company_name": "",
    "person_company_website": "",
    "person_stage_id": "",
    "personal_email_address": "",
    "personal_website": "",
    "phone": "",
    "phone_extension": "",
    "secondary_email_address": "",
    "state": "",
    "tags": "",
    "title": "",
    "twitter_handle": "",
    "work_city": "",
    "work_country": "",
    "work_state": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.put(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/people/:id.json"

payload <- "account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state="

encode <- "form"

response <- VERB("PUT", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/people/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :account_id => "",
  :city => "",
  :contact_restrictions => "",
  :country => "",
  :crm_id => "",
  :crm_id_type => "",
  :custom_fields => "",
  :do_not_contact => "",
  :email_address => "",
  :first_name => "",
  :home_phone => "",
  :import_id => "",
  :job_seniority => "",
  :last_name => "",
  :linkedin_url => "",
  :locale => "",
  :mobile_phone => "",
  :owner_id => "",
  :person_company_industry => "",
  :person_company_name => "",
  :person_company_website => "",
  :person_stage_id => "",
  :personal_email_address => "",
  :personal_website => "",
  :phone => "",
  :phone_extension => "",
  :secondary_email_address => "",
  :state => "",
  :tags => "",
  :title => "",
  :twitter_handle => "",
  :work_city => "",
  :work_country => "",
  :work_state => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.put('/baseUrl/v2/people/:id.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/people/:id.json";

    let payload = json!({
        "account_id": "",
        "city": "",
        "contact_restrictions": "",
        "country": "",
        "crm_id": "",
        "crm_id_type": "",
        "custom_fields": "",
        "do_not_contact": "",
        "email_address": "",
        "first_name": "",
        "home_phone": "",
        "import_id": "",
        "job_seniority": "",
        "last_name": "",
        "linkedin_url": "",
        "locale": "",
        "mobile_phone": "",
        "owner_id": "",
        "person_company_industry": "",
        "person_company_name": "",
        "person_company_website": "",
        "person_stage_id": "",
        "personal_email_address": "",
        "personal_website": "",
        "phone": "",
        "phone_extension": "",
        "secondary_email_address": "",
        "state": "",
        "tags": "",
        "title": "",
        "twitter_handle": "",
        "work_city": "",
        "work_country": "",
        "work_state": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/v2/people/:id.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data account_id= \
  --data city= \
  --data contact_restrictions= \
  --data country= \
  --data crm_id= \
  --data crm_id_type= \
  --data custom_fields= \
  --data do_not_contact= \
  --data email_address= \
  --data first_name= \
  --data home_phone= \
  --data import_id= \
  --data job_seniority= \
  --data last_name= \
  --data linkedin_url= \
  --data locale= \
  --data mobile_phone= \
  --data owner_id= \
  --data person_company_industry= \
  --data person_company_name= \
  --data person_company_website= \
  --data person_stage_id= \
  --data personal_email_address= \
  --data personal_website= \
  --data phone= \
  --data phone_extension= \
  --data secondary_email_address= \
  --data state= \
  --data tags= \
  --data title= \
  --data twitter_handle= \
  --data work_city= \
  --data work_country= \
  --data work_state=

http --form PUT {{baseUrl}}/v2/people/:id.json \
  content-type:application/x-www-form-urlencoded \
  account_id='' \
  city='' \
  contact_restrictions='' \
  country='' \
  crm_id='' \
  crm_id_type='' \
  custom_fields='' \
  do_not_contact='' \
  email_address='' \
  first_name='' \
  home_phone='' \
  import_id='' \
  job_seniority='' \
  last_name='' \
  linkedin_url='' \
  locale='' \
  mobile_phone='' \
  owner_id='' \
  person_company_industry='' \
  person_company_name='' \
  person_company_website='' \
  person_stage_id='' \
  personal_email_address='' \
  personal_website='' \
  phone='' \
  phone_extension='' \
  secondary_email_address='' \
  state='' \
  tags='' \
  title='' \
  twitter_handle='' \
  work_city='' \
  work_country='' \
  work_state=''

wget --quiet \
  --method PUT \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&work_city=&work_country=&work_state=' \
  --output-document \
  - {{baseUrl}}/v2/people/:id.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "account_id=".data(using: String.Encoding.utf8)!)
postData.append("&city=".data(using: String.Encoding.utf8)!)
postData.append("&contact_restrictions=".data(using: String.Encoding.utf8)!)
postData.append("&country=".data(using: String.Encoding.utf8)!)
postData.append("&crm_id=".data(using: String.Encoding.utf8)!)
postData.append("&crm_id_type=".data(using: String.Encoding.utf8)!)
postData.append("&custom_fields=".data(using: String.Encoding.utf8)!)
postData.append("&do_not_contact=".data(using: String.Encoding.utf8)!)
postData.append("&email_address=".data(using: String.Encoding.utf8)!)
postData.append("&first_name=".data(using: String.Encoding.utf8)!)
postData.append("&home_phone=".data(using: String.Encoding.utf8)!)
postData.append("&import_id=".data(using: String.Encoding.utf8)!)
postData.append("&job_seniority=".data(using: String.Encoding.utf8)!)
postData.append("&last_name=".data(using: String.Encoding.utf8)!)
postData.append("&linkedin_url=".data(using: String.Encoding.utf8)!)
postData.append("&locale=".data(using: String.Encoding.utf8)!)
postData.append("&mobile_phone=".data(using: String.Encoding.utf8)!)
postData.append("&owner_id=".data(using: String.Encoding.utf8)!)
postData.append("&person_company_industry=".data(using: String.Encoding.utf8)!)
postData.append("&person_company_name=".data(using: String.Encoding.utf8)!)
postData.append("&person_company_website=".data(using: String.Encoding.utf8)!)
postData.append("&person_stage_id=".data(using: String.Encoding.utf8)!)
postData.append("&personal_email_address=".data(using: String.Encoding.utf8)!)
postData.append("&personal_website=".data(using: String.Encoding.utf8)!)
postData.append("&phone=".data(using: String.Encoding.utf8)!)
postData.append("&phone_extension=".data(using: String.Encoding.utf8)!)
postData.append("&secondary_email_address=".data(using: String.Encoding.utf8)!)
postData.append("&state=".data(using: String.Encoding.utf8)!)
postData.append("&tags=".data(using: String.Encoding.utf8)!)
postData.append("&title=".data(using: String.Encoding.utf8)!)
postData.append("&twitter_handle=".data(using: String.Encoding.utf8)!)
postData.append("&work_city=".data(using: String.Encoding.utf8)!)
postData.append("&work_country=".data(using: String.Encoding.utf8)!)
postData.append("&work_state=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/people/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create a person stage

{{baseUrl}}/v2/person_stages.json

BODY formUrlEncoded

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/person_stages.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "name=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/person_stages.json" {:form-params {:name ""}})

require "http/client"

url = "{{baseUrl}}/v2/person_stages.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "name="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/person_stages.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "name", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/person_stages.json");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "name=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/person_stages.json"

	payload := strings.NewReader("name=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/person_stages.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 5

name=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/person_stages.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("name=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/person_stages.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("name="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "name=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/person_stages.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/person_stages.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("name=")
  .asString();

const data = 'name=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/person_stages.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/person_stages.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/person_stages.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({name: ''})
};

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}}/v2/person_stages.json',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    name: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "name=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/person_stages.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/person_stages.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/person_stages.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {name: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/person_stages.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/person_stages.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');

const url = '{{baseUrl}}/v2/person_stages.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"name=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/person_stages.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/person_stages.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "name=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/person_stages.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "name=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/person_stages.json', [
  'form_params' => [
    'name' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/person_stages.json');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'name' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'name' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/person_stages.json');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/person_stages.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'name='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/person_stages.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'name='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "name="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/person_stages.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/person_stages.json"

payload = { "name": "" }
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/person_stages.json"

payload <- "name="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/person_stages.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "name="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :name => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/person_stages.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/person_stages.json";

    let payload = json!({"name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/person_stages.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data name=

http --form POST {{baseUrl}}/v2/person_stages.json \
  content-type:application/x-www-form-urlencoded \
  name=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data name= \
  --output-document \
  - {{baseUrl}}/v2/person_stages.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "name=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/person_stages.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Delete an person stage

{{baseUrl}}/v2/person_stages/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/person_stages/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v2/person_stages/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/person_stages/:id.json"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v2/person_stages/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/person_stages/:id.json");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/person_stages/:id.json"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v2/person_stages/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/person_stages/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/person_stages/:id.json"))
    .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}}/v2/person_stages/:id.json")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v2/person_stages/:id.json")
  .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}}/v2/person_stages/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v2/person_stages/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/person_stages/:id.json';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/person_stages/:id.json',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/person_stages/:id.json")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/person_stages/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/v2/person_stages/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/person_stages/:id.json');

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}}/v2/person_stages/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/person_stages/:id.json';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/person_stages/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/person_stages/:id.json" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/person_stages/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v2/person_stages/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/person_stages/:id.json');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/person_stages/:id.json');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/person_stages/:id.json' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/person_stages/:id.json' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v2/person_stages/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/person_stages/:id.json"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/person_stages/:id.json"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/person_stages/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v2/person_stages/:id.json') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/person_stages/:id.json";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v2/person_stages/:id.json

http DELETE {{baseUrl}}/v2/person_stages/:id.json

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/person_stages/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/person_stages/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch a person stage

{{baseUrl}}/v2/person_stages/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/person_stages/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/person_stages/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/person_stages/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/person_stages/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/person_stages/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/person_stages/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/person_stages/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/person_stages/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/person_stages/:id.json"))
    .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}}/v2/person_stages/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/person_stages/:id.json")
  .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}}/v2/person_stages/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/person_stages/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/person_stages/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/person_stages/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/person_stages/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/person_stages/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/person_stages/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/person_stages/:id.json');

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}}/v2/person_stages/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/person_stages/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/person_stages/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/person_stages/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/person_stages/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/person_stages/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/person_stages/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/person_stages/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/person_stages/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/person_stages/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/person_stages/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/person_stages/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/person_stages/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/person_stages/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/person_stages/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/person_stages/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/person_stages/:id.json

http GET {{baseUrl}}/v2/person_stages/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/person_stages/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/person_stages/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List person stages

{{baseUrl}}/v2/person_stages.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/person_stages.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/person_stages.json")

require "http/client"

url = "{{baseUrl}}/v2/person_stages.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/person_stages.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/person_stages.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/person_stages.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/person_stages.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/person_stages.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/person_stages.json"))
    .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}}/v2/person_stages.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/person_stages.json")
  .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}}/v2/person_stages.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/person_stages.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/person_stages.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/person_stages.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/person_stages.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/person_stages.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/person_stages.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/person_stages.json');

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}}/v2/person_stages.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/person_stages.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/person_stages.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/person_stages.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/person_stages.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/person_stages.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/person_stages.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/person_stages.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/person_stages.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/person_stages.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/person_stages.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/person_stages.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/person_stages.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/person_stages.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/person_stages.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/person_stages.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/person_stages.json

http GET {{baseUrl}}/v2/person_stages.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/person_stages.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/person_stages.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT Update a person stage

{{baseUrl}}/v2/person_stages/:id.json

QUERY PARAMS

BODY formUrlEncoded

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/person_stages/:id.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "name=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v2/person_stages/:id.json" {:form-params {:name ""}})

require "http/client"

url = "{{baseUrl}}/v2/person_stages/:id.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "name="

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v2/person_stages/:id.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "name", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/person_stages/:id.json");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "name=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/person_stages/:id.json"

	payload := strings.NewReader("name=")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/v2/person_stages/:id.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 5

name=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v2/person_stages/:id.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("name=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/person_stages/:id.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("PUT", HttpRequest.BodyPublishers.ofString("name="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "name=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/person_stages/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v2/person_stages/:id.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("name=")
  .asString();

const data = 'name=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v2/person_stages/:id.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/person_stages/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/person_stages/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({name: ''})
};

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}}/v2/person_stages/:id.json',
  method: 'PUT',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    name: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "name=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/person_stages/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/person_stages/:id.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/person_stages/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {name: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/v2/person_stages/:id.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/person_stages/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('name', '');

const url = '{{baseUrl}}/v2/person_stages/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"name=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/person_stages/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/person_stages/:id.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "name=" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/person_stages/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => "name=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/v2/person_stages/:id.json', [
  'form_params' => [
    'name' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/person_stages/:id.json');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'name' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'name' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/person_stages/:id.json');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/person_stages/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'name='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/person_stages/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'name='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "name="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PUT", "/baseUrl/v2/person_stages/:id.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/person_stages/:id.json"

payload = { "name": "" }
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.put(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/person_stages/:id.json"

payload <- "name="

encode <- "form"

response <- VERB("PUT", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/person_stages/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "name="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :name => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.put('/baseUrl/v2/person_stages/:id.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/person_stages/:id.json";

    let payload = json!({"name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/v2/person_stages/:id.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data name=

http --form PUT {{baseUrl}}/v2/person_stages/:id.json \
  content-type:application/x-www-form-urlencoded \
  name=''

wget --quiet \
  --method PUT \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data name= \
  --output-document \
  - {{baseUrl}}/v2/person_stages/:id.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "name=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/person_stages/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Upsert a person

{{baseUrl}}/v2/person_upserts.json

BODY formUrlEncoded

account_id

city

contact_restrictions

country

crm_id

crm_id_type

custom_fields

do_not_contact

email_address

first_name

home_phone

import_id

job_seniority

last_name

linkedin_url

locale

mobile_phone

owner_id

person_company_industry

person_company_name

person_company_website

person_stage_id

personal_email_address

personal_website

phone

phone_extension

secondary_email_address

state

tags

title

twitter_handle

upsert_key

work_city

work_country

work_state

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/person_upserts.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&id=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&upsert_key=&work_city=&work_country=&work_state=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/person_upserts.json" {:form-params {:account_id ""
                                                                                 :city ""
                                                                                 :contact_restrictions ""
                                                                                 :country ""
                                                                                 :crm_id ""
                                                                                 :crm_id_type ""
                                                                                 :custom_fields ""
                                                                                 :do_not_contact ""
                                                                                 :email_address ""
                                                                                 :first_name ""
                                                                                 :home_phone ""
                                                                                 :id ""
                                                                                 :import_id ""
                                                                                 :job_seniority ""
                                                                                 :last_name ""
                                                                                 :linkedin_url ""
                                                                                 :locale ""
                                                                                 :mobile_phone ""
                                                                                 :owner_id ""
                                                                                 :person_company_industry ""
                                                                                 :person_company_name ""
                                                                                 :person_company_website ""
                                                                                 :person_stage_id ""
                                                                                 :personal_email_address ""
                                                                                 :personal_website ""
                                                                                 :phone ""
                                                                                 :phone_extension ""
                                                                                 :secondary_email_address ""
                                                                                 :state ""
                                                                                 :tags ""
                                                                                 :title ""
                                                                                 :twitter_handle ""
                                                                                 :upsert_key ""
                                                                                 :work_city ""
                                                                                 :work_country ""
                                                                                 :work_state ""}})

require "http/client"

url = "{{baseUrl}}/v2/person_upserts.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&id=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&upsert_key=&work_city=&work_country=&work_state="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/person_upserts.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "account_id", "" },
        { "city", "" },
        { "contact_restrictions", "" },
        { "country", "" },
        { "crm_id", "" },
        { "crm_id_type", "" },
        { "custom_fields", "" },
        { "do_not_contact", "" },
        { "email_address", "" },
        { "first_name", "" },
        { "home_phone", "" },
        { "id", "" },
        { "import_id", "" },
        { "job_seniority", "" },
        { "last_name", "" },
        { "linkedin_url", "" },
        { "locale", "" },
        { "mobile_phone", "" },
        { "owner_id", "" },
        { "person_company_industry", "" },
        { "person_company_name", "" },
        { "person_company_website", "" },
        { "person_stage_id", "" },
        { "personal_email_address", "" },
        { "personal_website", "" },
        { "phone", "" },
        { "phone_extension", "" },
        { "secondary_email_address", "" },
        { "state", "" },
        { "tags", "" },
        { "title", "" },
        { "twitter_handle", "" },
        { "upsert_key", "" },
        { "work_city", "" },
        { "work_country", "" },
        { "work_state", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/person_upserts.json");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&id=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&upsert_key=&work_city=&work_country=&work_state=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/person_upserts.json"

	payload := strings.NewReader("account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&id=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&upsert_key=&work_city=&work_country=&work_state=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/person_upserts.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 489

account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&id=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&upsert_key=&work_city=&work_country=&work_state=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/person_upserts.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&id=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&upsert_key=&work_city=&work_country=&work_state=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/person_upserts.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&id=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&upsert_key=&work_city=&work_country=&work_state="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&id=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&upsert_key=&work_city=&work_country=&work_state=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/person_upserts.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/person_upserts.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&id=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&upsert_key=&work_city=&work_country=&work_state=")
  .asString();

const data = 'account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&id=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&upsert_key=&work_city=&work_country=&work_state=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/person_upserts.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('account_id', '');
encodedParams.set('city', '');
encodedParams.set('contact_restrictions', '');
encodedParams.set('country', '');
encodedParams.set('crm_id', '');
encodedParams.set('crm_id_type', '');
encodedParams.set('custom_fields', '');
encodedParams.set('do_not_contact', '');
encodedParams.set('email_address', '');
encodedParams.set('first_name', '');
encodedParams.set('home_phone', '');
encodedParams.set('id', '');
encodedParams.set('import_id', '');
encodedParams.set('job_seniority', '');
encodedParams.set('last_name', '');
encodedParams.set('linkedin_url', '');
encodedParams.set('locale', '');
encodedParams.set('mobile_phone', '');
encodedParams.set('owner_id', '');
encodedParams.set('person_company_industry', '');
encodedParams.set('person_company_name', '');
encodedParams.set('person_company_website', '');
encodedParams.set('person_stage_id', '');
encodedParams.set('personal_email_address', '');
encodedParams.set('personal_website', '');
encodedParams.set('phone', '');
encodedParams.set('phone_extension', '');
encodedParams.set('secondary_email_address', '');
encodedParams.set('state', '');
encodedParams.set('tags', '');
encodedParams.set('title', '');
encodedParams.set('twitter_handle', '');
encodedParams.set('upsert_key', '');
encodedParams.set('work_city', '');
encodedParams.set('work_country', '');
encodedParams.set('work_state', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/person_upserts.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/person_upserts.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    account_id: '',
    city: '',
    contact_restrictions: '',
    country: '',
    crm_id: '',
    crm_id_type: '',
    custom_fields: '',
    do_not_contact: '',
    email_address: '',
    first_name: '',
    home_phone: '',
    id: '',
    import_id: '',
    job_seniority: '',
    last_name: '',
    linkedin_url: '',
    locale: '',
    mobile_phone: '',
    owner_id: '',
    person_company_industry: '',
    person_company_name: '',
    person_company_website: '',
    person_stage_id: '',
    personal_email_address: '',
    personal_website: '',
    phone: '',
    phone_extension: '',
    secondary_email_address: '',
    state: '',
    tags: '',
    title: '',
    twitter_handle: '',
    upsert_key: '',
    work_city: '',
    work_country: '',
    work_state: ''
  })
};

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}}/v2/person_upserts.json',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    account_id: '',
    city: '',
    contact_restrictions: '',
    country: '',
    crm_id: '',
    crm_id_type: '',
    custom_fields: '',
    do_not_contact: '',
    email_address: '',
    first_name: '',
    home_phone: '',
    id: '',
    import_id: '',
    job_seniority: '',
    last_name: '',
    linkedin_url: '',
    locale: '',
    mobile_phone: '',
    owner_id: '',
    person_company_industry: '',
    person_company_name: '',
    person_company_website: '',
    person_stage_id: '',
    personal_email_address: '',
    personal_website: '',
    phone: '',
    phone_extension: '',
    secondary_email_address: '',
    state: '',
    tags: '',
    title: '',
    twitter_handle: '',
    upsert_key: '',
    work_city: '',
    work_country: '',
    work_state: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&id=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&upsert_key=&work_city=&work_country=&work_state=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/person_upserts.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/person_upserts.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({
  account_id: '',
  city: '',
  contact_restrictions: '',
  country: '',
  crm_id: '',
  crm_id_type: '',
  custom_fields: '',
  do_not_contact: '',
  email_address: '',
  first_name: '',
  home_phone: '',
  id: '',
  import_id: '',
  job_seniority: '',
  last_name: '',
  linkedin_url: '',
  locale: '',
  mobile_phone: '',
  owner_id: '',
  person_company_industry: '',
  person_company_name: '',
  person_company_website: '',
  person_stage_id: '',
  personal_email_address: '',
  personal_website: '',
  phone: '',
  phone_extension: '',
  secondary_email_address: '',
  state: '',
  tags: '',
  title: '',
  twitter_handle: '',
  upsert_key: '',
  work_city: '',
  work_country: '',
  work_state: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/person_upserts.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    account_id: '',
    city: '',
    contact_restrictions: '',
    country: '',
    crm_id: '',
    crm_id_type: '',
    custom_fields: '',
    do_not_contact: '',
    email_address: '',
    first_name: '',
    home_phone: '',
    id: '',
    import_id: '',
    job_seniority: '',
    last_name: '',
    linkedin_url: '',
    locale: '',
    mobile_phone: '',
    owner_id: '',
    person_company_industry: '',
    person_company_name: '',
    person_company_website: '',
    person_stage_id: '',
    personal_email_address: '',
    personal_website: '',
    phone: '',
    phone_extension: '',
    secondary_email_address: '',
    state: '',
    tags: '',
    title: '',
    twitter_handle: '',
    upsert_key: '',
    work_city: '',
    work_country: '',
    work_state: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/person_upserts.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  account_id: '',
  city: '',
  contact_restrictions: '',
  country: '',
  crm_id: '',
  crm_id_type: '',
  custom_fields: '',
  do_not_contact: '',
  email_address: '',
  first_name: '',
  home_phone: '',
  id: '',
  import_id: '',
  job_seniority: '',
  last_name: '',
  linkedin_url: '',
  locale: '',
  mobile_phone: '',
  owner_id: '',
  person_company_industry: '',
  person_company_name: '',
  person_company_website: '',
  person_stage_id: '',
  personal_email_address: '',
  personal_website: '',
  phone: '',
  phone_extension: '',
  secondary_email_address: '',
  state: '',
  tags: '',
  title: '',
  twitter_handle: '',
  upsert_key: '',
  work_city: '',
  work_country: '',
  work_state: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('account_id', '');
encodedParams.set('city', '');
encodedParams.set('contact_restrictions', '');
encodedParams.set('country', '');
encodedParams.set('crm_id', '');
encodedParams.set('crm_id_type', '');
encodedParams.set('custom_fields', '');
encodedParams.set('do_not_contact', '');
encodedParams.set('email_address', '');
encodedParams.set('first_name', '');
encodedParams.set('home_phone', '');
encodedParams.set('id', '');
encodedParams.set('import_id', '');
encodedParams.set('job_seniority', '');
encodedParams.set('last_name', '');
encodedParams.set('linkedin_url', '');
encodedParams.set('locale', '');
encodedParams.set('mobile_phone', '');
encodedParams.set('owner_id', '');
encodedParams.set('person_company_industry', '');
encodedParams.set('person_company_name', '');
encodedParams.set('person_company_website', '');
encodedParams.set('person_stage_id', '');
encodedParams.set('personal_email_address', '');
encodedParams.set('personal_website', '');
encodedParams.set('phone', '');
encodedParams.set('phone_extension', '');
encodedParams.set('secondary_email_address', '');
encodedParams.set('state', '');
encodedParams.set('tags', '');
encodedParams.set('title', '');
encodedParams.set('twitter_handle', '');
encodedParams.set('upsert_key', '');
encodedParams.set('work_city', '');
encodedParams.set('work_country', '');
encodedParams.set('work_state', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/person_upserts.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('account_id', '');
encodedParams.set('city', '');
encodedParams.set('contact_restrictions', '');
encodedParams.set('country', '');
encodedParams.set('crm_id', '');
encodedParams.set('crm_id_type', '');
encodedParams.set('custom_fields', '');
encodedParams.set('do_not_contact', '');
encodedParams.set('email_address', '');
encodedParams.set('first_name', '');
encodedParams.set('home_phone', '');
encodedParams.set('id', '');
encodedParams.set('import_id', '');
encodedParams.set('job_seniority', '');
encodedParams.set('last_name', '');
encodedParams.set('linkedin_url', '');
encodedParams.set('locale', '');
encodedParams.set('mobile_phone', '');
encodedParams.set('owner_id', '');
encodedParams.set('person_company_industry', '');
encodedParams.set('person_company_name', '');
encodedParams.set('person_company_website', '');
encodedParams.set('person_stage_id', '');
encodedParams.set('personal_email_address', '');
encodedParams.set('personal_website', '');
encodedParams.set('phone', '');
encodedParams.set('phone_extension', '');
encodedParams.set('secondary_email_address', '');
encodedParams.set('state', '');
encodedParams.set('tags', '');
encodedParams.set('title', '');
encodedParams.set('twitter_handle', '');
encodedParams.set('upsert_key', '');
encodedParams.set('work_city', '');
encodedParams.set('work_country', '');
encodedParams.set('work_state', '');

const url = '{{baseUrl}}/v2/person_upserts.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"account_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&city=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&contact_restrictions=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&country=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&crm_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&crm_id_type=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&custom_fields=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&do_not_contact=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&email_address=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&first_name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&home_phone=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&import_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&job_seniority=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&last_name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&linkedin_url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&locale=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&mobile_phone=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&owner_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&person_company_industry=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&person_company_name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&person_company_website=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&person_stage_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&personal_email_address=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&personal_website=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&phone=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&phone_extension=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&secondary_email_address=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&state=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&tags=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&title=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&twitter_handle=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&upsert_key=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&work_city=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&work_country=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&work_state=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/person_upserts.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/person_upserts.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&id=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&upsert_key=&work_city=&work_country=&work_state=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/person_upserts.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&id=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&upsert_key=&work_city=&work_country=&work_state=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/person_upserts.json', [
  'form_params' => [
    'account_id' => '',
    'city' => '',
    'contact_restrictions' => '',
    'country' => '',
    'crm_id' => '',
    'crm_id_type' => '',
    'custom_fields' => '',
    'do_not_contact' => '',
    'email_address' => '',
    'first_name' => '',
    'home_phone' => '',
    'id' => '',
    'import_id' => '',
    'job_seniority' => '',
    'last_name' => '',
    'linkedin_url' => '',
    'locale' => '',
    'mobile_phone' => '',
    'owner_id' => '',
    'person_company_industry' => '',
    'person_company_name' => '',
    'person_company_website' => '',
    'person_stage_id' => '',
    'personal_email_address' => '',
    'personal_website' => '',
    'phone' => '',
    'phone_extension' => '',
    'secondary_email_address' => '',
    'state' => '',
    'tags' => '',
    'title' => '',
    'twitter_handle' => '',
    'upsert_key' => '',
    'work_city' => '',
    'work_country' => '',
    'work_state' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/person_upserts.json');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'account_id' => '',
  'city' => '',
  'contact_restrictions' => '',
  'country' => '',
  'crm_id' => '',
  'crm_id_type' => '',
  'custom_fields' => '',
  'do_not_contact' => '',
  'email_address' => '',
  'first_name' => '',
  'home_phone' => '',
  'id' => '',
  'import_id' => '',
  'job_seniority' => '',
  'last_name' => '',
  'linkedin_url' => '',
  'locale' => '',
  'mobile_phone' => '',
  'owner_id' => '',
  'person_company_industry' => '',
  'person_company_name' => '',
  'person_company_website' => '',
  'person_stage_id' => '',
  'personal_email_address' => '',
  'personal_website' => '',
  'phone' => '',
  'phone_extension' => '',
  'secondary_email_address' => '',
  'state' => '',
  'tags' => '',
  'title' => '',
  'twitter_handle' => '',
  'upsert_key' => '',
  'work_city' => '',
  'work_country' => '',
  'work_state' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'account_id' => '',
  'city' => '',
  'contact_restrictions' => '',
  'country' => '',
  'crm_id' => '',
  'crm_id_type' => '',
  'custom_fields' => '',
  'do_not_contact' => '',
  'email_address' => '',
  'first_name' => '',
  'home_phone' => '',
  'id' => '',
  'import_id' => '',
  'job_seniority' => '',
  'last_name' => '',
  'linkedin_url' => '',
  'locale' => '',
  'mobile_phone' => '',
  'owner_id' => '',
  'person_company_industry' => '',
  'person_company_name' => '',
  'person_company_website' => '',
  'person_stage_id' => '',
  'personal_email_address' => '',
  'personal_website' => '',
  'phone' => '',
  'phone_extension' => '',
  'secondary_email_address' => '',
  'state' => '',
  'tags' => '',
  'title' => '',
  'twitter_handle' => '',
  'upsert_key' => '',
  'work_city' => '',
  'work_country' => '',
  'work_state' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/person_upserts.json');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/person_upserts.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&id=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&upsert_key=&work_city=&work_country=&work_state='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/person_upserts.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&id=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&upsert_key=&work_city=&work_country=&work_state='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&id=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&upsert_key=&work_city=&work_country=&work_state="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/person_upserts.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/person_upserts.json"

payload = {
    "account_id": "",
    "city": "",
    "contact_restrictions": "",
    "country": "",
    "crm_id": "",
    "crm_id_type": "",
    "custom_fields": "",
    "do_not_contact": "",
    "email_address": "",
    "first_name": "",
    "home_phone": "",
    "id": "",
    "import_id": "",
    "job_seniority": "",
    "last_name": "",
    "linkedin_url": "",
    "locale": "",
    "mobile_phone": "",
    "owner_id": "",
    "person_company_industry": "",
    "person_company_name": "",
    "person_company_website": "",
    "person_stage_id": "",
    "personal_email_address": "",
    "personal_website": "",
    "phone": "",
    "phone_extension": "",
    "secondary_email_address": "",
    "state": "",
    "tags": "",
    "title": "",
    "twitter_handle": "",
    "upsert_key": "",
    "work_city": "",
    "work_country": "",
    "work_state": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/person_upserts.json"

payload <- "account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&id=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&upsert_key=&work_city=&work_country=&work_state="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/person_upserts.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&id=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&upsert_key=&work_city=&work_country=&work_state="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :account_id => "",
  :city => "",
  :contact_restrictions => "",
  :country => "",
  :crm_id => "",
  :crm_id_type => "",
  :custom_fields => "",
  :do_not_contact => "",
  :email_address => "",
  :first_name => "",
  :home_phone => "",
  :id => "",
  :import_id => "",
  :job_seniority => "",
  :last_name => "",
  :linkedin_url => "",
  :locale => "",
  :mobile_phone => "",
  :owner_id => "",
  :person_company_industry => "",
  :person_company_name => "",
  :person_company_website => "",
  :person_stage_id => "",
  :personal_email_address => "",
  :personal_website => "",
  :phone => "",
  :phone_extension => "",
  :secondary_email_address => "",
  :state => "",
  :tags => "",
  :title => "",
  :twitter_handle => "",
  :upsert_key => "",
  :work_city => "",
  :work_country => "",
  :work_state => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/person_upserts.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/person_upserts.json";

    let payload = json!({
        "account_id": "",
        "city": "",
        "contact_restrictions": "",
        "country": "",
        "crm_id": "",
        "crm_id_type": "",
        "custom_fields": "",
        "do_not_contact": "",
        "email_address": "",
        "first_name": "",
        "home_phone": "",
        "id": "",
        "import_id": "",
        "job_seniority": "",
        "last_name": "",
        "linkedin_url": "",
        "locale": "",
        "mobile_phone": "",
        "owner_id": "",
        "person_company_industry": "",
        "person_company_name": "",
        "person_company_website": "",
        "person_stage_id": "",
        "personal_email_address": "",
        "personal_website": "",
        "phone": "",
        "phone_extension": "",
        "secondary_email_address": "",
        "state": "",
        "tags": "",
        "title": "",
        "twitter_handle": "",
        "upsert_key": "",
        "work_city": "",
        "work_country": "",
        "work_state": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/person_upserts.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data account_id= \
  --data city= \
  --data contact_restrictions= \
  --data country= \
  --data crm_id= \
  --data crm_id_type= \
  --data custom_fields= \
  --data do_not_contact= \
  --data email_address= \
  --data first_name= \
  --data home_phone= \
  --data id= \
  --data import_id= \
  --data job_seniority= \
  --data last_name= \
  --data linkedin_url= \
  --data locale= \
  --data mobile_phone= \
  --data owner_id= \
  --data person_company_industry= \
  --data person_company_name= \
  --data person_company_website= \
  --data person_stage_id= \
  --data personal_email_address= \
  --data personal_website= \
  --data phone= \
  --data phone_extension= \
  --data secondary_email_address= \
  --data state= \
  --data tags= \
  --data title= \
  --data twitter_handle= \
  --data upsert_key= \
  --data work_city= \
  --data work_country= \
  --data work_state=

http --form POST {{baseUrl}}/v2/person_upserts.json \
  content-type:application/x-www-form-urlencoded \
  account_id='' \
  city='' \
  contact_restrictions='' \
  country='' \
  crm_id='' \
  crm_id_type='' \
  custom_fields='' \
  do_not_contact='' \
  email_address='' \
  first_name='' \
  home_phone='' \
  id='' \
  import_id='' \
  job_seniority='' \
  last_name='' \
  linkedin_url='' \
  locale='' \
  mobile_phone='' \
  owner_id='' \
  person_company_industry='' \
  person_company_name='' \
  person_company_website='' \
  person_stage_id='' \
  personal_email_address='' \
  personal_website='' \
  phone='' \
  phone_extension='' \
  secondary_email_address='' \
  state='' \
  tags='' \
  title='' \
  twitter_handle='' \
  upsert_key='' \
  work_city='' \
  work_country='' \
  work_state=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'account_id=&city=&contact_restrictions=&country=&crm_id=&crm_id_type=&custom_fields=&do_not_contact=&email_address=&first_name=&home_phone=&id=&import_id=&job_seniority=&last_name=&linkedin_url=&locale=&mobile_phone=&owner_id=&person_company_industry=&person_company_name=&person_company_website=&person_stage_id=&personal_email_address=&personal_website=&phone=&phone_extension=&secondary_email_address=&state=&tags=&title=&twitter_handle=&upsert_key=&work_city=&work_country=&work_state=' \
  --output-document \
  - {{baseUrl}}/v2/person_upserts.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "account_id=".data(using: String.Encoding.utf8)!)
postData.append("&city=".data(using: String.Encoding.utf8)!)
postData.append("&contact_restrictions=".data(using: String.Encoding.utf8)!)
postData.append("&country=".data(using: String.Encoding.utf8)!)
postData.append("&crm_id=".data(using: String.Encoding.utf8)!)
postData.append("&crm_id_type=".data(using: String.Encoding.utf8)!)
postData.append("&custom_fields=".data(using: String.Encoding.utf8)!)
postData.append("&do_not_contact=".data(using: String.Encoding.utf8)!)
postData.append("&email_address=".data(using: String.Encoding.utf8)!)
postData.append("&first_name=".data(using: String.Encoding.utf8)!)
postData.append("&home_phone=".data(using: String.Encoding.utf8)!)
postData.append("&id=".data(using: String.Encoding.utf8)!)
postData.append("&import_id=".data(using: String.Encoding.utf8)!)
postData.append("&job_seniority=".data(using: String.Encoding.utf8)!)
postData.append("&last_name=".data(using: String.Encoding.utf8)!)
postData.append("&linkedin_url=".data(using: String.Encoding.utf8)!)
postData.append("&locale=".data(using: String.Encoding.utf8)!)
postData.append("&mobile_phone=".data(using: String.Encoding.utf8)!)
postData.append("&owner_id=".data(using: String.Encoding.utf8)!)
postData.append("&person_company_industry=".data(using: String.Encoding.utf8)!)
postData.append("&person_company_name=".data(using: String.Encoding.utf8)!)
postData.append("&person_company_website=".data(using: String.Encoding.utf8)!)
postData.append("&person_stage_id=".data(using: String.Encoding.utf8)!)
postData.append("&personal_email_address=".data(using: String.Encoding.utf8)!)
postData.append("&personal_website=".data(using: String.Encoding.utf8)!)
postData.append("&phone=".data(using: String.Encoding.utf8)!)
postData.append("&phone_extension=".data(using: String.Encoding.utf8)!)
postData.append("&secondary_email_address=".data(using: String.Encoding.utf8)!)
postData.append("&state=".data(using: String.Encoding.utf8)!)
postData.append("&tags=".data(using: String.Encoding.utf8)!)
postData.append("&title=".data(using: String.Encoding.utf8)!)
postData.append("&twitter_handle=".data(using: String.Encoding.utf8)!)
postData.append("&upsert_key=".data(using: String.Encoding.utf8)!)
postData.append("&work_city=".data(using: String.Encoding.utf8)!)
postData.append("&work_country=".data(using: String.Encoding.utf8)!)
postData.append("&work_state=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/person_upserts.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch a phone number assignment

{{baseUrl}}/v2/phone_number_assignments/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/phone_number_assignments/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/phone_number_assignments/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/phone_number_assignments/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/phone_number_assignments/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/phone_number_assignments/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/phone_number_assignments/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/phone_number_assignments/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/phone_number_assignments/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/phone_number_assignments/:id.json"))
    .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}}/v2/phone_number_assignments/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/phone_number_assignments/:id.json")
  .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}}/v2/phone_number_assignments/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/phone_number_assignments/:id.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/phone_number_assignments/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/phone_number_assignments/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/phone_number_assignments/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/phone_number_assignments/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/phone_number_assignments/:id.json'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/phone_number_assignments/:id.json');

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}}/v2/phone_number_assignments/:id.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/phone_number_assignments/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/phone_number_assignments/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/phone_number_assignments/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/phone_number_assignments/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/phone_number_assignments/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/phone_number_assignments/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/phone_number_assignments/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/phone_number_assignments/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/phone_number_assignments/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/phone_number_assignments/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/phone_number_assignments/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/phone_number_assignments/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/phone_number_assignments/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/phone_number_assignments/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/phone_number_assignments/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/phone_number_assignments/:id.json

http GET {{baseUrl}}/v2/phone_number_assignments/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/phone_number_assignments/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/phone_number_assignments/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List phone number assignments

{{baseUrl}}/v2/phone_number_assignments.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/phone_number_assignments.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/phone_number_assignments.json")

require "http/client"

url = "{{baseUrl}}/v2/phone_number_assignments.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/phone_number_assignments.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/phone_number_assignments.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/phone_number_assignments.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/phone_number_assignments.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/phone_number_assignments.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/phone_number_assignments.json"))
    .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}}/v2/phone_number_assignments.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/phone_number_assignments.json")
  .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}}/v2/phone_number_assignments.json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/phone_number_assignments.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/phone_number_assignments.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/phone_number_assignments.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/phone_number_assignments.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/phone_number_assignments.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/phone_number_assignments.json'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/phone_number_assignments.json');

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}}/v2/phone_number_assignments.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/phone_number_assignments.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/phone_number_assignments.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/phone_number_assignments.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/phone_number_assignments.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/phone_number_assignments.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/phone_number_assignments.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/phone_number_assignments.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/phone_number_assignments.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/phone_number_assignments.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/phone_number_assignments.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/phone_number_assignments.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/phone_number_assignments.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/phone_number_assignments.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/phone_number_assignments.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/phone_number_assignments.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/phone_number_assignments.json

http GET {{baseUrl}}/v2/phone_number_assignments.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/phone_number_assignments.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/phone_number_assignments.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch recording setting

{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/phone_numbers/recording_settings/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json"))
    .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}}/v2/phone_numbers/recording_settings/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json")
  .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}}/v2/phone_numbers/recording_settings/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/phone_numbers/recording_settings/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json');

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}}/v2/phone_numbers/recording_settings/:id.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/phone_numbers/recording_settings/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/phone_numbers/recording_settings/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/phone_numbers/recording_settings/:id.json

http GET {{baseUrl}}/v2/phone_numbers/recording_settings/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/phone_numbers/recording_settings/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/phone_numbers/recording_settings/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create a saved list view

{{baseUrl}}/v2/saved_list_views.json

BODY formUrlEncoded

is_default

name

view

view_params

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/saved_list_views.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "is_default=&name=&view=&view_params=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/saved_list_views.json" {:form-params {:is_default ""
                                                                                   :name ""
                                                                                   :view ""
                                                                                   :view_params ""}})

require "http/client"

url = "{{baseUrl}}/v2/saved_list_views.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "is_default=&name=&view=&view_params="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/saved_list_views.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "is_default", "" },
        { "name", "" },
        { "view", "" },
        { "view_params", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/saved_list_views.json");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "is_default=&name=&view=&view_params=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/saved_list_views.json"

	payload := strings.NewReader("is_default=&name=&view=&view_params=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/saved_list_views.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 36

is_default=&name=&view=&view_params=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/saved_list_views.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("is_default=&name=&view=&view_params=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/saved_list_views.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("is_default=&name=&view=&view_params="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "is_default=&name=&view=&view_params=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/saved_list_views.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/saved_list_views.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("is_default=&name=&view=&view_params=")
  .asString();

const data = 'is_default=&name=&view=&view_params=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/saved_list_views.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('is_default', '');
encodedParams.set('name', '');
encodedParams.set('view', '');
encodedParams.set('view_params', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/saved_list_views.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/saved_list_views.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({is_default: '', name: '', view: '', view_params: ''})
};

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}}/v2/saved_list_views.json',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    is_default: '',
    name: '',
    view: '',
    view_params: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "is_default=&name=&view=&view_params=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/saved_list_views.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/saved_list_views.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({is_default: '', name: '', view: '', view_params: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/saved_list_views.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {is_default: '', name: '', view: '', view_params: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/saved_list_views.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  is_default: '',
  name: '',
  view: '',
  view_params: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('is_default', '');
encodedParams.set('name', '');
encodedParams.set('view', '');
encodedParams.set('view_params', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/saved_list_views.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('is_default', '');
encodedParams.set('name', '');
encodedParams.set('view', '');
encodedParams.set('view_params', '');

const url = '{{baseUrl}}/v2/saved_list_views.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"is_default=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&view=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&view_params=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/saved_list_views.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/saved_list_views.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "is_default=&name=&view=&view_params=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/saved_list_views.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "is_default=&name=&view=&view_params=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/saved_list_views.json', [
  'form_params' => [
    'is_default' => '',
    'name' => '',
    'view' => '',
    'view_params' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/saved_list_views.json');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'is_default' => '',
  'name' => '',
  'view' => '',
  'view_params' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'is_default' => '',
  'name' => '',
  'view' => '',
  'view_params' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/saved_list_views.json');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/saved_list_views.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'is_default=&name=&view=&view_params='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/saved_list_views.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'is_default=&name=&view=&view_params='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "is_default=&name=&view=&view_params="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/saved_list_views.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/saved_list_views.json"

payload = {
    "is_default": "",
    "name": "",
    "view": "",
    "view_params": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/saved_list_views.json"

payload <- "is_default=&name=&view=&view_params="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/saved_list_views.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "is_default=&name=&view=&view_params="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :is_default => "",
  :name => "",
  :view => "",
  :view_params => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/saved_list_views.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/saved_list_views.json";

    let payload = json!({
        "is_default": "",
        "name": "",
        "view": "",
        "view_params": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/saved_list_views.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data is_default= \
  --data name= \
  --data view= \
  --data view_params=

http --form POST {{baseUrl}}/v2/saved_list_views.json \
  content-type:application/x-www-form-urlencoded \
  is_default='' \
  name='' \
  view='' \
  view_params=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'is_default=&name=&view=&view_params=' \
  --output-document \
  - {{baseUrl}}/v2/saved_list_views.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "is_default=".data(using: String.Encoding.utf8)!)
postData.append("&name=".data(using: String.Encoding.utf8)!)
postData.append("&view=".data(using: String.Encoding.utf8)!)
postData.append("&view_params=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/saved_list_views.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Delete a saved list view

{{baseUrl}}/v2/saved_list_views/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/saved_list_views/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v2/saved_list_views/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/saved_list_views/:id.json"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v2/saved_list_views/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/saved_list_views/:id.json");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/saved_list_views/:id.json"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v2/saved_list_views/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/saved_list_views/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/saved_list_views/:id.json"))
    .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}}/v2/saved_list_views/:id.json")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v2/saved_list_views/:id.json")
  .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}}/v2/saved_list_views/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v2/saved_list_views/:id.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/saved_list_views/:id.json';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/saved_list_views/:id.json',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/saved_list_views/:id.json")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/saved_list_views/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v2/saved_list_views/:id.json'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/saved_list_views/:id.json');

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}}/v2/saved_list_views/:id.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/saved_list_views/:id.json';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/saved_list_views/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/saved_list_views/:id.json" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/saved_list_views/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v2/saved_list_views/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/saved_list_views/:id.json');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/saved_list_views/:id.json');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/saved_list_views/:id.json' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/saved_list_views/:id.json' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v2/saved_list_views/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/saved_list_views/:id.json"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/saved_list_views/:id.json"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/saved_list_views/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v2/saved_list_views/:id.json') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/saved_list_views/:id.json";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v2/saved_list_views/:id.json

http DELETE {{baseUrl}}/v2/saved_list_views/:id.json

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/saved_list_views/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/saved_list_views/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch a saved list view

{{baseUrl}}/v2/saved_list_views/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/saved_list_views/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/saved_list_views/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/saved_list_views/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/saved_list_views/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/saved_list_views/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/saved_list_views/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/saved_list_views/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/saved_list_views/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/saved_list_views/:id.json"))
    .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}}/v2/saved_list_views/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/saved_list_views/:id.json")
  .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}}/v2/saved_list_views/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/saved_list_views/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/saved_list_views/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/saved_list_views/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/saved_list_views/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/saved_list_views/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/saved_list_views/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/saved_list_views/:id.json');

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}}/v2/saved_list_views/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/saved_list_views/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/saved_list_views/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/saved_list_views/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/saved_list_views/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/saved_list_views/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/saved_list_views/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/saved_list_views/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/saved_list_views/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/saved_list_views/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/saved_list_views/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/saved_list_views/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/saved_list_views/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/saved_list_views/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/saved_list_views/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/saved_list_views/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/saved_list_views/:id.json

http GET {{baseUrl}}/v2/saved_list_views/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/saved_list_views/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/saved_list_views/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List saved list views

{{baseUrl}}/v2/saved_list_views.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/saved_list_views.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/saved_list_views.json")

require "http/client"

url = "{{baseUrl}}/v2/saved_list_views.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/saved_list_views.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/saved_list_views.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/saved_list_views.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/saved_list_views.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/saved_list_views.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/saved_list_views.json"))
    .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}}/v2/saved_list_views.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/saved_list_views.json")
  .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}}/v2/saved_list_views.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/saved_list_views.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/saved_list_views.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/saved_list_views.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/saved_list_views.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/saved_list_views.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/saved_list_views.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/saved_list_views.json');

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}}/v2/saved_list_views.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/saved_list_views.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/saved_list_views.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/saved_list_views.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/saved_list_views.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/saved_list_views.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/saved_list_views.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/saved_list_views.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/saved_list_views.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/saved_list_views.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/saved_list_views.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/saved_list_views.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/saved_list_views.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/saved_list_views.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/saved_list_views.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/saved_list_views.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/saved_list_views.json

http GET {{baseUrl}}/v2/saved_list_views.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/saved_list_views.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/saved_list_views.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT Update a saved list view

{{baseUrl}}/v2/saved_list_views/:id.json

QUERY PARAMS

BODY formUrlEncoded

is_default

name

view_params

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/saved_list_views/:id.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "is_default=&name=&view_params=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v2/saved_list_views/:id.json" {:form-params {:is_default ""
                                                                                      :name ""
                                                                                      :view_params ""}})

require "http/client"

url = "{{baseUrl}}/v2/saved_list_views/:id.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "is_default=&name=&view_params="

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v2/saved_list_views/:id.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "is_default", "" },
        { "name", "" },
        { "view_params", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/saved_list_views/:id.json");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "is_default=&name=&view_params=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/saved_list_views/:id.json"

	payload := strings.NewReader("is_default=&name=&view_params=")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/v2/saved_list_views/:id.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 30

is_default=&name=&view_params=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v2/saved_list_views/:id.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("is_default=&name=&view_params=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/saved_list_views/:id.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("PUT", HttpRequest.BodyPublishers.ofString("is_default=&name=&view_params="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "is_default=&name=&view_params=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/saved_list_views/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v2/saved_list_views/:id.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("is_default=&name=&view_params=")
  .asString();

const data = 'is_default=&name=&view_params=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v2/saved_list_views/:id.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('is_default', '');
encodedParams.set('name', '');
encodedParams.set('view_params', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/saved_list_views/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/saved_list_views/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({is_default: '', name: '', view_params: ''})
};

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}}/v2/saved_list_views/:id.json',
  method: 'PUT',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    is_default: '',
    name: '',
    view_params: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "is_default=&name=&view_params=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/saved_list_views/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/saved_list_views/:id.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({is_default: '', name: '', view_params: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/saved_list_views/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {is_default: '', name: '', view_params: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/v2/saved_list_views/:id.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  is_default: '',
  name: '',
  view_params: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('is_default', '');
encodedParams.set('name', '');
encodedParams.set('view_params', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/saved_list_views/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('is_default', '');
encodedParams.set('name', '');
encodedParams.set('view_params', '');

const url = '{{baseUrl}}/v2/saved_list_views/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"is_default=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&name=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&view_params=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/saved_list_views/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/saved_list_views/:id.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "is_default=&name=&view_params=" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/saved_list_views/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => "is_default=&name=&view_params=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/v2/saved_list_views/:id.json', [
  'form_params' => [
    'is_default' => '',
    'name' => '',
    'view_params' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/saved_list_views/:id.json');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'is_default' => '',
  'name' => '',
  'view_params' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'is_default' => '',
  'name' => '',
  'view_params' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/saved_list_views/:id.json');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/saved_list_views/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'is_default=&name=&view_params='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/saved_list_views/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'is_default=&name=&view_params='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "is_default=&name=&view_params="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PUT", "/baseUrl/v2/saved_list_views/:id.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/saved_list_views/:id.json"

payload = {
    "is_default": "",
    "name": "",
    "view_params": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.put(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/saved_list_views/:id.json"

payload <- "is_default=&name=&view_params="

encode <- "form"

response <- VERB("PUT", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/saved_list_views/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "is_default=&name=&view_params="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :is_default => "",
  :name => "",
  :view_params => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.put('/baseUrl/v2/saved_list_views/:id.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/saved_list_views/:id.json";

    let payload = json!({
        "is_default": "",
        "name": "",
        "view_params": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/v2/saved_list_views/:id.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data is_default= \
  --data name= \
  --data view_params=

http --form PUT {{baseUrl}}/v2/saved_list_views/:id.json \
  content-type:application/x-www-form-urlencoded \
  is_default='' \
  name='' \
  view_params=''

wget --quiet \
  --method PUT \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'is_default=&name=&view_params=' \
  --output-document \
  - {{baseUrl}}/v2/saved_list_views/:id.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "is_default=".data(using: String.Encoding.utf8)!)
postData.append("&name=".data(using: String.Encoding.utf8)!)
postData.append("&view_params=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/saved_list_views/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch a step

{{baseUrl}}/v2/steps/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/steps/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/steps/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/steps/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/steps/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/steps/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/steps/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/steps/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/steps/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/steps/:id.json"))
    .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}}/v2/steps/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/steps/:id.json")
  .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}}/v2/steps/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/steps/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/steps/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/steps/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/steps/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/steps/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/steps/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/steps/:id.json');

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}}/v2/steps/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/steps/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/steps/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/steps/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/steps/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/steps/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/steps/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/steps/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/steps/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/steps/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/steps/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/steps/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/steps/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/steps/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/steps/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/steps/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/steps/:id.json

http GET {{baseUrl}}/v2/steps/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/steps/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/steps/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List steps

{{baseUrl}}/v2/steps.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/steps.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/steps.json")

require "http/client"

url = "{{baseUrl}}/v2/steps.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/steps.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/steps.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/steps.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/steps.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/steps.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/steps.json"))
    .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}}/v2/steps.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/steps.json")
  .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}}/v2/steps.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/steps.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/steps.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/steps.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/steps.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/steps.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/steps.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/steps.json');

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}}/v2/steps.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/steps.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/steps.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/steps.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/steps.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/steps.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/steps.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/steps.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/steps.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/steps.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/steps.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/steps.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/steps.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/steps.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/steps.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/steps.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/steps.json

http GET {{baseUrl}}/v2/steps.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/steps.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/steps.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List successes

{{baseUrl}}/v2/successes.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/successes.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/successes.json")

require "http/client"

url = "{{baseUrl}}/v2/successes.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/successes.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/successes.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/successes.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/successes.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/successes.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/successes.json"))
    .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}}/v2/successes.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/successes.json")
  .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}}/v2/successes.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/successes.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/successes.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/successes.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/successes.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/successes.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/successes.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/successes.json');

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}}/v2/successes.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/successes.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/successes.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/successes.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/successes.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/successes.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/successes.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/successes.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/successes.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/successes.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/successes.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/successes.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/successes.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/successes.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/successes.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/successes.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/successes.json

http GET {{baseUrl}}/v2/successes.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/successes.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/successes.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List team tags

{{baseUrl}}/v2/tags.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tags.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tags.json")

require "http/client"

url = "{{baseUrl}}/v2/tags.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tags.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tags.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tags.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tags.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tags.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tags.json"))
    .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}}/v2/tags.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tags.json")
  .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}}/v2/tags.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/tags.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tags.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tags.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tags.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tags.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/tags.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tags.json');

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}}/v2/tags.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tags.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tags.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tags.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tags.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tags.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tags.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tags.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tags.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tags.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tags.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tags.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tags.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tags.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tags.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tags.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tags.json

http GET {{baseUrl}}/v2/tags.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tags.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tags.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create a Task

{{baseUrl}}/v2/tasks.json

BODY formUrlEncoded

current_state

description

due_date

idempotency_key

person_id

remind_at

subject

task_type

user_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tasks.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "current_state=&description=&due_date=&idempotency_key=&person_id=&remind_at=&subject=&task_type=&user_id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/tasks.json" {:form-params {:current_state ""
                                                                        :description ""
                                                                        :due_date ""
                                                                        :idempotency_key ""
                                                                        :person_id ""
                                                                        :remind_at ""
                                                                        :subject ""
                                                                        :task_type ""
                                                                        :user_id ""}})

require "http/client"

url = "{{baseUrl}}/v2/tasks.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "current_state=&description=&due_date=&idempotency_key=&person_id=&remind_at=&subject=&task_type=&user_id="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/tasks.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "current_state", "" },
        { "description", "" },
        { "due_date", "" },
        { "idempotency_key", "" },
        { "person_id", "" },
        { "remind_at", "" },
        { "subject", "" },
        { "task_type", "" },
        { "user_id", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tasks.json");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "current_state=&description=&due_date=&idempotency_key=&person_id=&remind_at=&subject=&task_type=&user_id=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tasks.json"

	payload := strings.NewReader("current_state=&description=&due_date=&idempotency_key=&person_id=&remind_at=&subject=&task_type=&user_id=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/tasks.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 105

current_state=&description=&due_date=&idempotency_key=&person_id=&remind_at=&subject=&task_type=&user_id=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/tasks.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("current_state=&description=&due_date=&idempotency_key=&person_id=&remind_at=&subject=&task_type=&user_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tasks.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("current_state=&description=&due_date=&idempotency_key=&person_id=&remind_at=&subject=&task_type=&user_id="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "current_state=&description=&due_date=&idempotency_key=&person_id=&remind_at=&subject=&task_type=&user_id=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/tasks.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/tasks.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("current_state=&description=&due_date=&idempotency_key=&person_id=&remind_at=&subject=&task_type=&user_id=")
  .asString();

const data = 'current_state=&description=&due_date=&idempotency_key=&person_id=&remind_at=&subject=&task_type=&user_id=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/tasks.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('current_state', '');
encodedParams.set('description', '');
encodedParams.set('due_date', '');
encodedParams.set('idempotency_key', '');
encodedParams.set('person_id', '');
encodedParams.set('remind_at', '');
encodedParams.set('subject', '');
encodedParams.set('task_type', '');
encodedParams.set('user_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/tasks.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tasks.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    current_state: '',
    description: '',
    due_date: '',
    idempotency_key: '',
    person_id: '',
    remind_at: '',
    subject: '',
    task_type: '',
    user_id: ''
  })
};

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}}/v2/tasks.json',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    current_state: '',
    description: '',
    due_date: '',
    idempotency_key: '',
    person_id: '',
    remind_at: '',
    subject: '',
    task_type: '',
    user_id: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "current_state=&description=&due_date=&idempotency_key=&person_id=&remind_at=&subject=&task_type=&user_id=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/tasks.json")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tasks.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({
  current_state: '',
  description: '',
  due_date: '',
  idempotency_key: '',
  person_id: '',
  remind_at: '',
  subject: '',
  task_type: '',
  user_id: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/tasks.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    current_state: '',
    description: '',
    due_date: '',
    idempotency_key: '',
    person_id: '',
    remind_at: '',
    subject: '',
    task_type: '',
    user_id: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/tasks.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  current_state: '',
  description: '',
  due_date: '',
  idempotency_key: '',
  person_id: '',
  remind_at: '',
  subject: '',
  task_type: '',
  user_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('current_state', '');
encodedParams.set('description', '');
encodedParams.set('due_date', '');
encodedParams.set('idempotency_key', '');
encodedParams.set('person_id', '');
encodedParams.set('remind_at', '');
encodedParams.set('subject', '');
encodedParams.set('task_type', '');
encodedParams.set('user_id', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/tasks.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('current_state', '');
encodedParams.set('description', '');
encodedParams.set('due_date', '');
encodedParams.set('idempotency_key', '');
encodedParams.set('person_id', '');
encodedParams.set('remind_at', '');
encodedParams.set('subject', '');
encodedParams.set('task_type', '');
encodedParams.set('user_id', '');

const url = '{{baseUrl}}/v2/tasks.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"current_state=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&description=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&due_date=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&idempotency_key=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&person_id=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&remind_at=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&subject=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&task_type=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&user_id=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tasks.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tasks.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "current_state=&description=&due_date=&idempotency_key=&person_id=&remind_at=&subject=&task_type=&user_id=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tasks.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "current_state=&description=&due_date=&idempotency_key=&person_id=&remind_at=&subject=&task_type=&user_id=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/tasks.json', [
  'form_params' => [
    'current_state' => '',
    'description' => '',
    'due_date' => '',
    'idempotency_key' => '',
    'person_id' => '',
    'remind_at' => '',
    'subject' => '',
    'task_type' => '',
    'user_id' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tasks.json');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'current_state' => '',
  'description' => '',
  'due_date' => '',
  'idempotency_key' => '',
  'person_id' => '',
  'remind_at' => '',
  'subject' => '',
  'task_type' => '',
  'user_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'current_state' => '',
  'description' => '',
  'due_date' => '',
  'idempotency_key' => '',
  'person_id' => '',
  'remind_at' => '',
  'subject' => '',
  'task_type' => '',
  'user_id' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/tasks.json');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tasks.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'current_state=&description=&due_date=&idempotency_key=&person_id=&remind_at=&subject=&task_type=&user_id='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tasks.json' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'current_state=&description=&due_date=&idempotency_key=&person_id=&remind_at=&subject=&task_type=&user_id='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "current_state=&description=&due_date=&idempotency_key=&person_id=&remind_at=&subject=&task_type=&user_id="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/tasks.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tasks.json"

payload = {
    "current_state": "",
    "description": "",
    "due_date": "",
    "idempotency_key": "",
    "person_id": "",
    "remind_at": "",
    "subject": "",
    "task_type": "",
    "user_id": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tasks.json"

payload <- "current_state=&description=&due_date=&idempotency_key=&person_id=&remind_at=&subject=&task_type=&user_id="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tasks.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "current_state=&description=&due_date=&idempotency_key=&person_id=&remind_at=&subject=&task_type=&user_id="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :current_state => "",
  :description => "",
  :due_date => "",
  :idempotency_key => "",
  :person_id => "",
  :remind_at => "",
  :subject => "",
  :task_type => "",
  :user_id => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/tasks.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tasks.json";

    let payload = json!({
        "current_state": "",
        "description": "",
        "due_date": "",
        "idempotency_key": "",
        "person_id": "",
        "remind_at": "",
        "subject": "",
        "task_type": "",
        "user_id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/tasks.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data current_state= \
  --data description= \
  --data due_date= \
  --data idempotency_key= \
  --data person_id= \
  --data remind_at= \
  --data subject= \
  --data task_type= \
  --data user_id=

http --form POST {{baseUrl}}/v2/tasks.json \
  content-type:application/x-www-form-urlencoded \
  current_state='' \
  description='' \
  due_date='' \
  idempotency_key='' \
  person_id='' \
  remind_at='' \
  subject='' \
  task_type='' \
  user_id=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'current_state=&description=&due_date=&idempotency_key=&person_id=&remind_at=&subject=&task_type=&user_id=' \
  --output-document \
  - {{baseUrl}}/v2/tasks.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "current_state=".data(using: String.Encoding.utf8)!)
postData.append("&description=".data(using: String.Encoding.utf8)!)
postData.append("&due_date=".data(using: String.Encoding.utf8)!)
postData.append("&idempotency_key=".data(using: String.Encoding.utf8)!)
postData.append("&person_id=".data(using: String.Encoding.utf8)!)
postData.append("&remind_at=".data(using: String.Encoding.utf8)!)
postData.append("&subject=".data(using: String.Encoding.utf8)!)
postData.append("&task_type=".data(using: String.Encoding.utf8)!)
postData.append("&user_id=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tasks.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch a task

{{baseUrl}}/v2/tasks/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tasks/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tasks/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/tasks/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tasks/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tasks/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tasks/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tasks/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tasks/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tasks/:id.json"))
    .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}}/v2/tasks/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tasks/:id.json")
  .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}}/v2/tasks/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/tasks/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tasks/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tasks/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tasks/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tasks/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/tasks/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tasks/:id.json');

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}}/v2/tasks/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tasks/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tasks/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tasks/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tasks/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tasks/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tasks/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tasks/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tasks/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tasks/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tasks/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tasks/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tasks/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tasks/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tasks/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tasks/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tasks/:id.json

http GET {{baseUrl}}/v2/tasks/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tasks/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tasks/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List tasks

{{baseUrl}}/v2/tasks.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tasks.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tasks.json")

require "http/client"

url = "{{baseUrl}}/v2/tasks.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tasks.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tasks.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tasks.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tasks.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tasks.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tasks.json"))
    .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}}/v2/tasks.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tasks.json")
  .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}}/v2/tasks.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/tasks.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tasks.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tasks.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tasks.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tasks.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/tasks.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tasks.json');

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}}/v2/tasks.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tasks.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tasks.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tasks.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tasks.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tasks.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tasks.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tasks.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tasks.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tasks.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tasks.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tasks.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tasks.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tasks.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tasks.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tasks.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tasks.json

http GET {{baseUrl}}/v2/tasks.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tasks.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tasks.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT Update a Task

{{baseUrl}}/v2/tasks/:id.json

QUERY PARAMS

BODY formUrlEncoded

current_state

description

due_date

is_logged

remind_at

subject

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tasks/:id.json");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "current_state=&description=&due_date=&is_logged=&remind_at=&subject=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v2/tasks/:id.json" {:form-params {:current_state ""
                                                                           :description ""
                                                                           :due_date ""
                                                                           :is_logged ""
                                                                           :remind_at ""
                                                                           :subject ""}})

require "http/client"

url = "{{baseUrl}}/v2/tasks/:id.json"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "current_state=&description=&due_date=&is_logged=&remind_at=&subject="

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v2/tasks/:id.json"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "current_state", "" },
        { "description", "" },
        { "due_date", "" },
        { "is_logged", "" },
        { "remind_at", "" },
        { "subject", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tasks/:id.json");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "current_state=&description=&due_date=&is_logged=&remind_at=&subject=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tasks/:id.json"

	payload := strings.NewReader("current_state=&description=&due_date=&is_logged=&remind_at=&subject=")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/v2/tasks/:id.json HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 68

current_state=&description=&due_date=&is_logged=&remind_at=&subject=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v2/tasks/:id.json")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("current_state=&description=&due_date=&is_logged=&remind_at=&subject=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tasks/:id.json"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("PUT", HttpRequest.BodyPublishers.ofString("current_state=&description=&due_date=&is_logged=&remind_at=&subject="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "current_state=&description=&due_date=&is_logged=&remind_at=&subject=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/tasks/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v2/tasks/:id.json")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("current_state=&description=&due_date=&is_logged=&remind_at=&subject=")
  .asString();

const data = 'current_state=&description=&due_date=&is_logged=&remind_at=&subject=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v2/tasks/:id.json');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('current_state', '');
encodedParams.set('description', '');
encodedParams.set('due_date', '');
encodedParams.set('is_logged', '');
encodedParams.set('remind_at', '');
encodedParams.set('subject', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/tasks/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tasks/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    current_state: '',
    description: '',
    due_date: '',
    is_logged: '',
    remind_at: '',
    subject: ''
  })
};

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}}/v2/tasks/:id.json',
  method: 'PUT',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    current_state: '',
    description: '',
    due_date: '',
    is_logged: '',
    remind_at: '',
    subject: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "current_state=&description=&due_date=&is_logged=&remind_at=&subject=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/tasks/:id.json")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tasks/:id.json',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({
  current_state: '',
  description: '',
  due_date: '',
  is_logged: '',
  remind_at: '',
  subject: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/tasks/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    current_state: '',
    description: '',
    due_date: '',
    is_logged: '',
    remind_at: '',
    subject: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/v2/tasks/:id.json');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  current_state: '',
  description: '',
  due_date: '',
  is_logged: '',
  remind_at: '',
  subject: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('current_state', '');
encodedParams.set('description', '');
encodedParams.set('due_date', '');
encodedParams.set('is_logged', '');
encodedParams.set('remind_at', '');
encodedParams.set('subject', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/tasks/:id.json',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('current_state', '');
encodedParams.set('description', '');
encodedParams.set('due_date', '');
encodedParams.set('is_logged', '');
encodedParams.set('remind_at', '');
encodedParams.set('subject', '');

const url = '{{baseUrl}}/v2/tasks/:id.json';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"current_state=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&description=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&due_date=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&is_logged=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&remind_at=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&subject=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tasks/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tasks/:id.json" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "current_state=&description=&due_date=&is_logged=&remind_at=&subject=" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tasks/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => "current_state=&description=&due_date=&is_logged=&remind_at=&subject=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/v2/tasks/:id.json', [
  'form_params' => [
    'current_state' => '',
    'description' => '',
    'due_date' => '',
    'is_logged' => '',
    'remind_at' => '',
    'subject' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tasks/:id.json');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'current_state' => '',
  'description' => '',
  'due_date' => '',
  'is_logged' => '',
  'remind_at' => '',
  'subject' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'current_state' => '',
  'description' => '',
  'due_date' => '',
  'is_logged' => '',
  'remind_at' => '',
  'subject' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/tasks/:id.json');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tasks/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'current_state=&description=&due_date=&is_logged=&remind_at=&subject='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tasks/:id.json' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'current_state=&description=&due_date=&is_logged=&remind_at=&subject='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "current_state=&description=&due_date=&is_logged=&remind_at=&subject="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PUT", "/baseUrl/v2/tasks/:id.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tasks/:id.json"

payload = {
    "current_state": "",
    "description": "",
    "due_date": "",
    "is_logged": "",
    "remind_at": "",
    "subject": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.put(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tasks/:id.json"

payload <- "current_state=&description=&due_date=&is_logged=&remind_at=&subject="

encode <- "form"

response <- VERB("PUT", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tasks/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "current_state=&description=&due_date=&is_logged=&remind_at=&subject="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :current_state => "",
  :description => "",
  :due_date => "",
  :is_logged => "",
  :remind_at => "",
  :subject => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.put('/baseUrl/v2/tasks/:id.json') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tasks/:id.json";

    let payload = json!({
        "current_state": "",
        "description": "",
        "due_date": "",
        "is_logged": "",
        "remind_at": "",
        "subject": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/v2/tasks/:id.json \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data current_state= \
  --data description= \
  --data due_date= \
  --data is_logged= \
  --data remind_at= \
  --data subject=

http --form PUT {{baseUrl}}/v2/tasks/:id.json \
  content-type:application/x-www-form-urlencoded \
  current_state='' \
  description='' \
  due_date='' \
  is_logged='' \
  remind_at='' \
  subject=''

wget --quiet \
  --method PUT \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'current_state=&description=&due_date=&is_logged=&remind_at=&subject=' \
  --output-document \
  - {{baseUrl}}/v2/tasks/:id.json

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "current_state=".data(using: String.Encoding.utf8)!)
postData.append("&description=".data(using: String.Encoding.utf8)!)
postData.append("&due_date=".data(using: String.Encoding.utf8)!)
postData.append("&is_logged=".data(using: String.Encoding.utf8)!)
postData.append("&remind_at=".data(using: String.Encoding.utf8)!)
postData.append("&subject=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tasks/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch current team

{{baseUrl}}/v2/team.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/team.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/team.json")

require "http/client"

url = "{{baseUrl}}/v2/team.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/team.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/team.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/team.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/team.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/team.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/team.json"))
    .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}}/v2/team.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/team.json")
  .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}}/v2/team.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/team.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/team.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/team.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/team.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/team.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/team.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/team.json');

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}}/v2/team.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/team.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/team.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/team.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/team.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/team.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/team.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/team.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/team.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/team.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/team.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/team.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/team.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/team.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/team.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/team.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/team.json

http GET {{baseUrl}}/v2/team.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/team.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/team.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List team template attachments

{{baseUrl}}/v2/team_template_attachments.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/team_template_attachments.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/team_template_attachments.json")

require "http/client"

url = "{{baseUrl}}/v2/team_template_attachments.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/team_template_attachments.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/team_template_attachments.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/team_template_attachments.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/team_template_attachments.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/team_template_attachments.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/team_template_attachments.json"))
    .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}}/v2/team_template_attachments.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/team_template_attachments.json")
  .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}}/v2/team_template_attachments.json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/team_template_attachments.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/team_template_attachments.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/team_template_attachments.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/team_template_attachments.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/team_template_attachments.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/team_template_attachments.json'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/team_template_attachments.json');

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}}/v2/team_template_attachments.json'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/team_template_attachments.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/team_template_attachments.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/team_template_attachments.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/team_template_attachments.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/team_template_attachments.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/team_template_attachments.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/team_template_attachments.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/team_template_attachments.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/team_template_attachments.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/team_template_attachments.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/team_template_attachments.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/team_template_attachments.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/team_template_attachments.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/team_template_attachments.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/team_template_attachments.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/team_template_attachments.json

http GET {{baseUrl}}/v2/team_template_attachments.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/team_template_attachments.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/team_template_attachments.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch a team template

{{baseUrl}}/v2/team_templates/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/team_templates/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/team_templates/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/team_templates/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/team_templates/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/team_templates/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/team_templates/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/team_templates/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/team_templates/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/team_templates/:id.json"))
    .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}}/v2/team_templates/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/team_templates/:id.json")
  .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}}/v2/team_templates/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/team_templates/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/team_templates/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/team_templates/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/team_templates/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/team_templates/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/team_templates/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/team_templates/:id.json');

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}}/v2/team_templates/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/team_templates/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/team_templates/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/team_templates/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/team_templates/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/team_templates/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/team_templates/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/team_templates/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/team_templates/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/team_templates/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/team_templates/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/team_templates/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/team_templates/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/team_templates/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/team_templates/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/team_templates/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/team_templates/:id.json

http GET {{baseUrl}}/v2/team_templates/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/team_templates/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/team_templates/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List team templates

{{baseUrl}}/v2/team_templates.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/team_templates.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/team_templates.json")

require "http/client"

url = "{{baseUrl}}/v2/team_templates.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/team_templates.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/team_templates.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/team_templates.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/team_templates.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/team_templates.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/team_templates.json"))
    .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}}/v2/team_templates.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/team_templates.json")
  .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}}/v2/team_templates.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/team_templates.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/team_templates.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/team_templates.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/team_templates.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/team_templates.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/team_templates.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/team_templates.json');

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}}/v2/team_templates.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/team_templates.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/team_templates.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/team_templates.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/team_templates.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/team_templates.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/team_templates.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/team_templates.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/team_templates.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/team_templates.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/team_templates.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/team_templates.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/team_templates.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/team_templates.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/team_templates.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/team_templates.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/team_templates.json

http GET {{baseUrl}}/v2/team_templates.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/team_templates.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/team_templates.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch a user

{{baseUrl}}/v2/users/:id.json

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/users/:id.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/users/:id.json")

require "http/client"

url = "{{baseUrl}}/v2/users/:id.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/users/:id.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/users/:id.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/users/:id.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/users/:id.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/users/:id.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/users/:id.json"))
    .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}}/v2/users/:id.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/users/:id.json")
  .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}}/v2/users/:id.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/users/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/users/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/users/:id.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/users/:id.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/users/:id.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/users/:id.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/users/:id.json');

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}}/v2/users/:id.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/users/:id.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/users/:id.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/users/:id.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/users/:id.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/users/:id.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/users/:id.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/users/:id.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/users/:id.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/users/:id.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/users/:id.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/users/:id.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/users/:id.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/users/:id.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/users/:id.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/users/:id.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/users/:id.json

http GET {{baseUrl}}/v2/users/:id.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/users/:id.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/users/:id.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List users

{{baseUrl}}/v2/users.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/users.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/users.json")

require "http/client"

url = "{{baseUrl}}/v2/users.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/users.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/users.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/users.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/users.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/users.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/users.json"))
    .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}}/v2/users.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/users.json")
  .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}}/v2/users.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/users.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/users.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/users.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/users.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/users.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/users.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/users.json');

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}}/v2/users.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/users.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/users.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/users.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/users.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/users.json');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/users.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/users.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/users.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/users.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/users.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/users.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/users.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/users.json")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/users.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/users.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/users.json

http GET {{baseUrl}}/v2/users.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/users.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/users.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create a webhook subscription

{{baseUrl}}/v2/webhook_subscriptions

BODY formUrlEncoded

callback_token

callback_url

event_type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/webhook_subscriptions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "callback_token=&callback_url=&event_type=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/webhook_subscriptions" {:form-params {:callback_token ""
                                                                                   :callback_url ""
                                                                                   :event_type ""}})

require "http/client"

url = "{{baseUrl}}/v2/webhook_subscriptions"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "callback_token=&callback_url=&event_type="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/webhook_subscriptions"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "callback_token", "" },
        { "callback_url", "" },
        { "event_type", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/webhook_subscriptions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "callback_token=&callback_url=&event_type=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/webhook_subscriptions"

	payload := strings.NewReader("callback_token=&callback_url=&event_type=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/webhook_subscriptions HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 41

callback_token=&callback_url=&event_type=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/webhook_subscriptions")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("callback_token=&callback_url=&event_type=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/webhook_subscriptions"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("callback_token=&callback_url=&event_type="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "callback_token=&callback_url=&event_type=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/webhook_subscriptions")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/webhook_subscriptions")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("callback_token=&callback_url=&event_type=")
  .asString();

const data = 'callback_token=&callback_url=&event_type=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/webhook_subscriptions');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('callback_token', '');
encodedParams.set('callback_url', '');
encodedParams.set('event_type', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/webhook_subscriptions',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/webhook_subscriptions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({callback_token: '', callback_url: '', event_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}}/v2/webhook_subscriptions',
  method: 'POST',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    callback_token: '',
    callback_url: '',
    event_type: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "callback_token=&callback_url=&event_type=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/webhook_subscriptions")
  .post(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/webhook_subscriptions',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({callback_token: '', callback_url: '', event_type: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/webhook_subscriptions',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {callback_token: '', callback_url: '', event_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}}/v2/webhook_subscriptions');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  callback_token: '',
  callback_url: '',
  event_type: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('callback_token', '');
encodedParams.set('callback_url', '');
encodedParams.set('event_type', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/webhook_subscriptions',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('callback_token', '');
encodedParams.set('callback_url', '');
encodedParams.set('event_type', '');

const url = '{{baseUrl}}/v2/webhook_subscriptions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"callback_token=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&callback_url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&event_type=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/webhook_subscriptions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/webhook_subscriptions" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "callback_token=&callback_url=&event_type=" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/webhook_subscriptions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "callback_token=&callback_url=&event_type=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/webhook_subscriptions', [
  'form_params' => [
    'callback_token' => '',
    'callback_url' => '',
    'event_type' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/webhook_subscriptions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'callback_token' => '',
  'callback_url' => '',
  'event_type' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'callback_token' => '',
  'callback_url' => '',
  'event_type' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/webhook_subscriptions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/webhook_subscriptions' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'callback_token=&callback_url=&event_type='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/webhook_subscriptions' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'callback_token=&callback_url=&event_type='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "callback_token=&callback_url=&event_type="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("POST", "/baseUrl/v2/webhook_subscriptions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/webhook_subscriptions"

payload = {
    "callback_token": "",
    "callback_url": "",
    "event_type": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/webhook_subscriptions"

payload <- "callback_token=&callback_url=&event_type="

encode <- "form"

response <- VERB("POST", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/webhook_subscriptions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "callback_token=&callback_url=&event_type="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :callback_token => "",
  :callback_url => "",
  :event_type => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/v2/webhook_subscriptions') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/webhook_subscriptions";

    let payload = json!({
        "callback_token": "",
        "callback_url": "",
        "event_type": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v2/webhook_subscriptions \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data callback_token= \
  --data callback_url= \
  --data event_type=

http --form POST {{baseUrl}}/v2/webhook_subscriptions \
  content-type:application/x-www-form-urlencoded \
  callback_token='' \
  callback_url='' \
  event_type=''

wget --quiet \
  --method POST \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'callback_token=&callback_url=&event_type=' \
  --output-document \
  - {{baseUrl}}/v2/webhook_subscriptions

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "callback_token=".data(using: String.Encoding.utf8)!)
postData.append("&callback_url=".data(using: String.Encoding.utf8)!)
postData.append("&event_type=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/webhook_subscriptions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Delete a webhook subscription

{{baseUrl}}/v2/webhook_subscriptions/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/webhook_subscriptions/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v2/webhook_subscriptions/:id")

require "http/client"

url = "{{baseUrl}}/v2/webhook_subscriptions/:id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v2/webhook_subscriptions/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/webhook_subscriptions/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/webhook_subscriptions/:id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v2/webhook_subscriptions/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/webhook_subscriptions/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/webhook_subscriptions/:id"))
    .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}}/v2/webhook_subscriptions/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v2/webhook_subscriptions/:id")
  .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}}/v2/webhook_subscriptions/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v2/webhook_subscriptions/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/webhook_subscriptions/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/webhook_subscriptions/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/webhook_subscriptions/:id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/webhook_subscriptions/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v2/webhook_subscriptions/:id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/webhook_subscriptions/:id');

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}}/v2/webhook_subscriptions/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/webhook_subscriptions/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/webhook_subscriptions/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/webhook_subscriptions/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/webhook_subscriptions/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v2/webhook_subscriptions/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/webhook_subscriptions/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/webhook_subscriptions/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/webhook_subscriptions/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/webhook_subscriptions/:id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v2/webhook_subscriptions/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/webhook_subscriptions/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/webhook_subscriptions/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/webhook_subscriptions/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v2/webhook_subscriptions/:id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/webhook_subscriptions/:id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v2/webhook_subscriptions/:id

http DELETE {{baseUrl}}/v2/webhook_subscriptions/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/webhook_subscriptions/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/webhook_subscriptions/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Fetch a webhook subscription

{{baseUrl}}/v2/webhook_subscriptions/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/webhook_subscriptions/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/webhook_subscriptions/:id")

require "http/client"

url = "{{baseUrl}}/v2/webhook_subscriptions/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/webhook_subscriptions/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/webhook_subscriptions/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/webhook_subscriptions/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/webhook_subscriptions/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/webhook_subscriptions/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/webhook_subscriptions/:id"))
    .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}}/v2/webhook_subscriptions/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/webhook_subscriptions/:id")
  .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}}/v2/webhook_subscriptions/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/webhook_subscriptions/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/webhook_subscriptions/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/webhook_subscriptions/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/webhook_subscriptions/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/webhook_subscriptions/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/webhook_subscriptions/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/webhook_subscriptions/:id');

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}}/v2/webhook_subscriptions/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/webhook_subscriptions/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/webhook_subscriptions/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/webhook_subscriptions/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/webhook_subscriptions/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/webhook_subscriptions/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/webhook_subscriptions/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/webhook_subscriptions/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/webhook_subscriptions/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/webhook_subscriptions/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/webhook_subscriptions/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/webhook_subscriptions/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/webhook_subscriptions/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/webhook_subscriptions/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/webhook_subscriptions/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/webhook_subscriptions/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/webhook_subscriptions/:id

http GET {{baseUrl}}/v2/webhook_subscriptions/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/webhook_subscriptions/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/webhook_subscriptions/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List webhook subscriptions

{{baseUrl}}/v2/webhook_subscriptions

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/webhook_subscriptions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/webhook_subscriptions")

require "http/client"

url = "{{baseUrl}}/v2/webhook_subscriptions"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/webhook_subscriptions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/webhook_subscriptions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/webhook_subscriptions"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/webhook_subscriptions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/webhook_subscriptions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/webhook_subscriptions"))
    .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}}/v2/webhook_subscriptions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/webhook_subscriptions")
  .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}}/v2/webhook_subscriptions');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/webhook_subscriptions'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/webhook_subscriptions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/webhook_subscriptions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/webhook_subscriptions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/webhook_subscriptions',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/webhook_subscriptions'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/webhook_subscriptions');

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}}/v2/webhook_subscriptions'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/webhook_subscriptions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/webhook_subscriptions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/webhook_subscriptions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/webhook_subscriptions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/webhook_subscriptions');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/webhook_subscriptions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/webhook_subscriptions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/webhook_subscriptions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/webhook_subscriptions' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/webhook_subscriptions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/webhook_subscriptions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/webhook_subscriptions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/webhook_subscriptions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/webhook_subscriptions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/webhook_subscriptions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/webhook_subscriptions

http GET {{baseUrl}}/v2/webhook_subscriptions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/webhook_subscriptions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/webhook_subscriptions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT Update a webhook subscription

{{baseUrl}}/v2/webhook_subscriptions/:id

QUERY PARAMS

BODY formUrlEncoded

enabled

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/webhook_subscriptions/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "enabled=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v2/webhook_subscriptions/:id" {:form-params {:enabled ""}})

require "http/client"

url = "{{baseUrl}}/v2/webhook_subscriptions/:id"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "enabled="

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v2/webhook_subscriptions/:id"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "enabled", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/webhook_subscriptions/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "enabled=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/webhook_subscriptions/:id"

	payload := strings.NewReader("enabled=")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/v2/webhook_subscriptions/:id HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 8

enabled=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v2/webhook_subscriptions/:id")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("enabled=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/webhook_subscriptions/:id"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("PUT", HttpRequest.BodyPublishers.ofString("enabled="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "enabled=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/webhook_subscriptions/:id")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v2/webhook_subscriptions/:id")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("enabled=")
  .asString();

const data = 'enabled=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v2/webhook_subscriptions/:id');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('enabled', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/webhook_subscriptions/:id',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/webhook_subscriptions/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({enabled: ''})
};

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}}/v2/webhook_subscriptions/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    enabled: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "enabled=")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/webhook_subscriptions/:id")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/webhook_subscriptions/:id',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(qs.stringify({enabled: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/webhook_subscriptions/:id',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {enabled: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/v2/webhook_subscriptions/:id');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  enabled: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('enabled', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/webhook_subscriptions/:id',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('enabled', '');

const url = '{{baseUrl}}/v2/webhook_subscriptions/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"enabled=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/webhook_subscriptions/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/webhook_subscriptions/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "enabled=" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/webhook_subscriptions/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => "enabled=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/v2/webhook_subscriptions/:id', [
  'form_params' => [
    'enabled' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/webhook_subscriptions/:id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'enabled' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(new http\QueryString([
  'enabled' => ''
]));

$request->setRequestUrl('{{baseUrl}}/v2/webhook_subscriptions/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/webhook_subscriptions/:id' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'enabled='

$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/webhook_subscriptions/:id' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'enabled='

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "enabled="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PUT", "/baseUrl/v2/webhook_subscriptions/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/webhook_subscriptions/:id"

payload = { "enabled": "" }
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.put(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/webhook_subscriptions/:id"

payload <- "enabled="

encode <- "form"

response <- VERB("PUT", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/webhook_subscriptions/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "enabled="

response = http.request(request)
puts response.read_body

require 'faraday'

data = {
  :enabled => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.put('/baseUrl/v2/webhook_subscriptions/:id') do |req|
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/webhook_subscriptions/:id";

    let payload = json!({"enabled": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/v2/webhook_subscriptions/:id \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data enabled=

http --form PUT {{baseUrl}}/v2/webhook_subscriptions/:id \
  content-type:application/x-www-form-urlencoded \
  enabled=''

wget --quiet \
  --method PUT \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data enabled= \
  --output-document \
  - {{baseUrl}}/v2/webhook_subscriptions/:id

import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "enabled=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/webhook_subscriptions/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()