WhatsApp Business API
DELETE
Delete-Media-Providers
{{baseUrl}}/settings/application/media/providers/:ProviderName
QUERY PARAMS
ProviderName
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/settings/application/media/providers/:ProviderName");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/settings/application/media/providers/:ProviderName")require "http/client"
url = "{{baseUrl}}/settings/application/media/providers/:ProviderName"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/settings/application/media/providers/:ProviderName"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/settings/application/media/providers/:ProviderName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/settings/application/media/providers/:ProviderName"
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/settings/application/media/providers/:ProviderName HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/settings/application/media/providers/:ProviderName")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/settings/application/media/providers/:ProviderName"))
.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}}/settings/application/media/providers/:ProviderName")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/settings/application/media/providers/:ProviderName")
.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}}/settings/application/media/providers/:ProviderName');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/settings/application/media/providers/:ProviderName'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/settings/application/media/providers/:ProviderName';
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}}/settings/application/media/providers/:ProviderName',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/settings/application/media/providers/:ProviderName")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/settings/application/media/providers/:ProviderName',
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}}/settings/application/media/providers/:ProviderName'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/settings/application/media/providers/:ProviderName');
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}}/settings/application/media/providers/:ProviderName'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/settings/application/media/providers/:ProviderName';
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}}/settings/application/media/providers/:ProviderName"]
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}}/settings/application/media/providers/:ProviderName" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/settings/application/media/providers/:ProviderName",
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}}/settings/application/media/providers/:ProviderName');
echo $response->getBody();setUrl('{{baseUrl}}/settings/application/media/providers/:ProviderName');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/settings/application/media/providers/:ProviderName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/settings/application/media/providers/:ProviderName' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/settings/application/media/providers/:ProviderName' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/settings/application/media/providers/:ProviderName")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/settings/application/media/providers/:ProviderName"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/settings/application/media/providers/:ProviderName"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/settings/application/media/providers/:ProviderName")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/settings/application/media/providers/:ProviderName') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/settings/application/media/providers/:ProviderName";
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}}/settings/application/media/providers/:ProviderNamehttp DELETE {{baseUrl}}/settings/application/media/providers/:ProviderNamewget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/settings/application/media/providers/:ProviderNameimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/settings/application/media/providers/:ProviderName")! 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
Get-Application-Settings
{{baseUrl}}/settings/application
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/settings/application");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/settings/application")require "http/client"
url = "{{baseUrl}}/settings/application"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/settings/application"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/settings/application");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/settings/application"
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/settings/application HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/settings/application")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/settings/application"))
.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}}/settings/application")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/settings/application")
.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}}/settings/application');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/settings/application'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/settings/application';
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}}/settings/application',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/settings/application")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/settings/application',
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}}/settings/application'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/settings/application');
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}}/settings/application'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/settings/application';
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}}/settings/application"]
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}}/settings/application" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/settings/application",
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}}/settings/application');
echo $response->getBody();setUrl('{{baseUrl}}/settings/application');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/settings/application');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/settings/application' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/settings/application' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/settings/application")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/settings/application"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/settings/application"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/settings/application")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/settings/application') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/settings/application";
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}}/settings/applicationhttp GET {{baseUrl}}/settings/applicationwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/settings/applicationimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/settings/application")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"callback_backoff_delay_ms": 3000,
"callback_persist": true,
"max_callback_backoff_delay_ms": 900000,
"media": {
"auto_download": [
"image",
"document",
"audio"
]
},
"on_call_pager": "",
"pass_through": false,
"sent_status": false,
"webhooks": {
"max_concurrent_requests": 12,
"url": ""
}
}
GET
Get-Media-Providers
{{baseUrl}}/settings/application/media/providers
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/settings/application/media/providers");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/settings/application/media/providers")require "http/client"
url = "{{baseUrl}}/settings/application/media/providers"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/settings/application/media/providers"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/settings/application/media/providers");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/settings/application/media/providers"
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/settings/application/media/providers HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/settings/application/media/providers")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/settings/application/media/providers"))
.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}}/settings/application/media/providers")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/settings/application/media/providers")
.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}}/settings/application/media/providers');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/settings/application/media/providers'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/settings/application/media/providers';
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}}/settings/application/media/providers',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/settings/application/media/providers")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/settings/application/media/providers',
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}}/settings/application/media/providers'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/settings/application/media/providers');
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}}/settings/application/media/providers'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/settings/application/media/providers';
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}}/settings/application/media/providers"]
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}}/settings/application/media/providers" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/settings/application/media/providers",
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}}/settings/application/media/providers');
echo $response->getBody();setUrl('{{baseUrl}}/settings/application/media/providers');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/settings/application/media/providers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/settings/application/media/providers' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/settings/application/media/providers' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/settings/application/media/providers")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/settings/application/media/providers"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/settings/application/media/providers"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/settings/application/media/providers")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/settings/application/media/providers') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/settings/application/media/providers";
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}}/settings/application/media/providershttp GET {{baseUrl}}/settings/application/media/providerswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/settings/application/media/providersimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/settings/application/media/providers")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"settings": {
"application": {
"media": {
"providers": [
{
"config": {
"basic": {
"password": "your-password",
"username": "your-username"
}
},
"name": "your-first-provider",
"type": "www"
},
{
"config": {
"bearer": "your-bearer-token"
},
"name": "your-second-provider",
"type": "www"
}
]
}
}
}
}
DELETE
Reset-Application-Settings
{{baseUrl}}/settings/application
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/settings/application");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/settings/application")require "http/client"
url = "{{baseUrl}}/settings/application"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/settings/application"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/settings/application");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/settings/application"
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/settings/application HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/settings/application")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/settings/application"))
.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}}/settings/application")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/settings/application")
.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}}/settings/application');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/settings/application'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/settings/application';
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}}/settings/application',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/settings/application")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/settings/application',
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}}/settings/application'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/settings/application');
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}}/settings/application'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/settings/application';
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}}/settings/application"]
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}}/settings/application" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/settings/application",
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}}/settings/application');
echo $response->getBody();setUrl('{{baseUrl}}/settings/application');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/settings/application');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/settings/application' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/settings/application' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/settings/application")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/settings/application"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/settings/application"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/settings/application")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/settings/application') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/settings/application";
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}}/settings/applicationhttp DELETE {{baseUrl}}/settings/applicationwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/settings/applicationimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/settings/application")! 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()
POST
Set-Shards
{{baseUrl}}/account/shards
BODY json
{
"cc": "",
"phone_number": "",
"pin": "",
"shards": 0
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/shards");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"cc\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\",\n \"shards\": 32\n}");
CURLcode ret = curl_easy_perform(hnd); (require '[clj-http.client :as client])
(client/post "{{baseUrl}}/account/shards" {:content-type :json
:form-params {:cc ""
:phone_number ""
:pin ""
:shards 32}}) require "http/client"
url = "{{baseUrl}}/account/shards"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"cc\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\",\n \"shards\": 32\n}"
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}}/account/shards"),
Content = new StringContent("{\n \"cc\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\",\n \"shards\": 32\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
} var client = new RestClient("{{baseUrl}}/account/shards");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"cc\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\",\n \"shards\": 32\n}", ParameterType.RequestBody);
var response = client.Execute(request); package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/account/shards"
payload := strings.NewReader("{\n \"cc\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\",\n \"shards\": 32\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
} POST /baseUrl/account/shards HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 107
{
"cc": "",
"phone_number": "",
"pin": "",
"shards": 32
} AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/shards")
.setHeader("content-type", "application/json")
.setBody("{\n \"cc\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\",\n \"shards\": 32\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close(); HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/account/shards"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"cc\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\",\n \"shards\": 32\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"cc\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\",\n \"shards\": 32\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/account/shards")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute(); HttpResponse response = Unirest.post("{{baseUrl}}/account/shards")
.header("content-type", "application/json")
.body("{\n \"cc\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\",\n \"shards\": 32\n}")
.asString(); const data = JSON.stringify({
cc: '',
phone_number: '',
pin: '',
shards: 32
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/account/shards');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data); import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/account/shards',
headers: {'content-type': 'application/json'},
data: {
cc: '',
phone_number: '',
pin: '',
shards: 32
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
} const url = '{{baseUrl}}/account/shards';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"cc":"","phone_number":"","pin":"","shards":32}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
} const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/account/shards',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "cc": "",\n "phone_number": "",\n "pin": "",\n "shards": 32\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
}); val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"cc\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\",\n \"shards\": 32\n}")
val request = Request.Builder()
.url("{{baseUrl}}/account/shards")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute() const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/account/shards',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
cc: '',
phone_number: '',
pin: '',
shards: 32
}));
req.end(); const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/account/shards',
headers: {'content-type': 'application/json'},
body: {
cc: '',
phone_number: '',
pin: '',
shards: 32
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
}); const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/account/shards');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
cc: '',
phone_number: '',
pin: '',
shards: 32
});
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}}/account/shards',
headers: {'content-type': 'application/json'},
data: {
cc: '',
phone_number: '',
pin: '',
shards: 32
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
} const fetch = require('node-fetch');
const url = '{{baseUrl}}/account/shards';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"cc":"","phone_number":"","pin":"","shards":32}'
};
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/json" };
NSDictionary *parameters = @{ @"cc": @"",
@"phone_number": @"",
@"pin": @"",
@"shards": @32 };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/shards"]
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}}/account/shards" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"cc\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\",\n \"shards\": 32\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/account/shards",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'cc' => '',
'phone_number' => '',
'pin' => '',
'shards' => 32
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
} request('POST', '{{baseUrl}}/account/shards', [
'body' => '{
"cc": "",
"phone_number": "",
"pin": "",
"shards": 32
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody(); setUrl('{{baseUrl}}/account/shards');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'cc' => '',
'phone_number' => '',
'pin' => '',
'shards' => 32
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
} append(json_encode([
'cc' => '',
'phone_number' => '',
'pin' => '',
'shards' => 32
]));
$request->setRequestUrl('{{baseUrl}}/account/shards');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody(); $headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/shards' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"cc": "",
"phone_number": "",
"pin": "",
"shards": 32
}' $headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/shards' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"cc": "",
"phone_number": "",
"pin": "",
"shards": 32
}' import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"cc\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\",\n \"shards\": 32\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/account/shards", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8")) import requests
url = "{{baseUrl}}/account/shards"
payload = {
"cc": "",
"phone_number": "",
"pin": "",
"shards": 32
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json()) library(httr)
url <- "{{baseUrl}}/account/shards"
payload <- "{\n \"cc\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\",\n \"shards\": 32\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text") require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/account/shards")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"cc\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\",\n \"shards\": 32\n}"
response = http.request(request)
puts response.read_body require 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/account/shards') do |req|
req.body = "{\n \"cc\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\",\n \"shards\": 32\n}"
end
puts response.status
puts response.body use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/account/shards";
let payload = json!({
"cc": "",
"phone_number": "",
"pin": "",
"shards": 32
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/account/shards \
--header 'content-type: application/json' \
--data '{
"cc": "",
"phone_number": "",
"pin": "",
"shards": 32
}' echo '{
"cc": "",
"phone_number": "",
"pin": "",
"shards": 32
}' | \
http POST {{baseUrl}}/account/shards \
content-type:application/json wget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "cc": "",\n "phone_number": "",\n "pin": "",\n "shards": 32\n}' \
--output-document \
- {{baseUrl}}/account/shards import Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"cc": "",
"phone_number": "",
"pin": "",
"shards": 32
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/shards")! 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()
PATCH
Update-Application-Settings
{{baseUrl}}/settings/application
BODY json
{
"callback_backoff_delay_ms": "",
"callback_persist": false,
"heartbeat_interval": 0,
"max_callback_backoff_delay_ms": "",
"media": {
"auto_download": []
},
"on_call_pager": "",
"pass_through": false,
"sent_status": false,
"unhealthy_interval": 0,
"webhooks": {
"max_concurrent_requests": 0,
"url": ""
}
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/settings/application");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"callback_backoff_delay_ms\": \"\",\n \"callback_persist\": false,\n \"heartbeat_interval\": 0,\n \"max_callback_backoff_delay_ms\": \"\",\n \"media\": {\n \"auto_download\": []\n },\n \"on_call_pager\": \"\",\n \"pass_through\": false,\n \"sent_status\": false,\n \"unhealthy_interval\": 0,\n \"webhooks\": {\n \"max_concurrent_requests\": 0,\n \"url\": \"\"\n }\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/settings/application" {:content-type :json
:form-params {:callback_backoff_delay_ms ""
:callback_persist false
:heartbeat_interval 0
:max_callback_backoff_delay_ms ""
:media {:auto_download []}
:on_call_pager ""
:pass_through false
:sent_status false
:unhealthy_interval 0
:webhooks {:max_concurrent_requests 0
:url ""}}})require "http/client"
url = "{{baseUrl}}/settings/application"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"callback_backoff_delay_ms\": \"\",\n \"callback_persist\": false,\n \"heartbeat_interval\": 0,\n \"max_callback_backoff_delay_ms\": \"\",\n \"media\": {\n \"auto_download\": []\n },\n \"on_call_pager\": \"\",\n \"pass_through\": false,\n \"sent_status\": false,\n \"unhealthy_interval\": 0,\n \"webhooks\": {\n \"max_concurrent_requests\": 0,\n \"url\": \"\"\n }\n}"
response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/settings/application"),
Content = new StringContent("{\n \"callback_backoff_delay_ms\": \"\",\n \"callback_persist\": false,\n \"heartbeat_interval\": 0,\n \"max_callback_backoff_delay_ms\": \"\",\n \"media\": {\n \"auto_download\": []\n },\n \"on_call_pager\": \"\",\n \"pass_through\": false,\n \"sent_status\": false,\n \"unhealthy_interval\": 0,\n \"webhooks\": {\n \"max_concurrent_requests\": 0,\n \"url\": \"\"\n }\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/settings/application");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"callback_backoff_delay_ms\": \"\",\n \"callback_persist\": false,\n \"heartbeat_interval\": 0,\n \"max_callback_backoff_delay_ms\": \"\",\n \"media\": {\n \"auto_download\": []\n },\n \"on_call_pager\": \"\",\n \"pass_through\": false,\n \"sent_status\": false,\n \"unhealthy_interval\": 0,\n \"webhooks\": {\n \"max_concurrent_requests\": 0,\n \"url\": \"\"\n }\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/settings/application"
payload := strings.NewReader("{\n \"callback_backoff_delay_ms\": \"\",\n \"callback_persist\": false,\n \"heartbeat_interval\": 0,\n \"max_callback_backoff_delay_ms\": \"\",\n \"media\": {\n \"auto_download\": []\n },\n \"on_call_pager\": \"\",\n \"pass_through\": false,\n \"sent_status\": false,\n \"unhealthy_interval\": 0,\n \"webhooks\": {\n \"max_concurrent_requests\": 0,\n \"url\": \"\"\n }\n}")
req, _ := http.NewRequest("PATCH", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/settings/application HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 342
{
"callback_backoff_delay_ms": "",
"callback_persist": false,
"heartbeat_interval": 0,
"max_callback_backoff_delay_ms": "",
"media": {
"auto_download": []
},
"on_call_pager": "",
"pass_through": false,
"sent_status": false,
"unhealthy_interval": 0,
"webhooks": {
"max_concurrent_requests": 0,
"url": ""
}
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/settings/application")
.setHeader("content-type", "application/json")
.setBody("{\n \"callback_backoff_delay_ms\": \"\",\n \"callback_persist\": false,\n \"heartbeat_interval\": 0,\n \"max_callback_backoff_delay_ms\": \"\",\n \"media\": {\n \"auto_download\": []\n },\n \"on_call_pager\": \"\",\n \"pass_through\": false,\n \"sent_status\": false,\n \"unhealthy_interval\": 0,\n \"webhooks\": {\n \"max_concurrent_requests\": 0,\n \"url\": \"\"\n }\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/settings/application"))
.header("content-type", "application/json")
.method("PATCH", HttpRequest.BodyPublishers.ofString("{\n \"callback_backoff_delay_ms\": \"\",\n \"callback_persist\": false,\n \"heartbeat_interval\": 0,\n \"max_callback_backoff_delay_ms\": \"\",\n \"media\": {\n \"auto_download\": []\n },\n \"on_call_pager\": \"\",\n \"pass_through\": false,\n \"sent_status\": false,\n \"unhealthy_interval\": 0,\n \"webhooks\": {\n \"max_concurrent_requests\": 0,\n \"url\": \"\"\n }\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"callback_backoff_delay_ms\": \"\",\n \"callback_persist\": false,\n \"heartbeat_interval\": 0,\n \"max_callback_backoff_delay_ms\": \"\",\n \"media\": {\n \"auto_download\": []\n },\n \"on_call_pager\": \"\",\n \"pass_through\": false,\n \"sent_status\": false,\n \"unhealthy_interval\": 0,\n \"webhooks\": {\n \"max_concurrent_requests\": 0,\n \"url\": \"\"\n }\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/settings/application")
.patch(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/settings/application")
.header("content-type", "application/json")
.body("{\n \"callback_backoff_delay_ms\": \"\",\n \"callback_persist\": false,\n \"heartbeat_interval\": 0,\n \"max_callback_backoff_delay_ms\": \"\",\n \"media\": {\n \"auto_download\": []\n },\n \"on_call_pager\": \"\",\n \"pass_through\": false,\n \"sent_status\": false,\n \"unhealthy_interval\": 0,\n \"webhooks\": {\n \"max_concurrent_requests\": 0,\n \"url\": \"\"\n }\n}")
.asString(); const data = JSON.stringify({
callback_backoff_delay_ms: '',
callback_persist: false,
heartbeat_interval: 0,
max_callback_backoff_delay_ms: '',
media: {
auto_download: []
},
on_call_pager: '',
pass_through: false,
sent_status: false,
unhealthy_interval: 0,
webhooks: {
max_concurrent_requests: 0,
url: ''
}
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/settings/application');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/settings/application',
headers: {'content-type': 'application/json'},
data: {
callback_backoff_delay_ms: '',
callback_persist: false,
heartbeat_interval: 0,
max_callback_backoff_delay_ms: '',
media: {auto_download: []},
on_call_pager: '',
pass_through: false,
sent_status: false,
unhealthy_interval: 0,
webhooks: {max_concurrent_requests: 0, url: ''}
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/settings/application';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"callback_backoff_delay_ms":"","callback_persist":false,"heartbeat_interval":0,"max_callback_backoff_delay_ms":"","media":{"auto_download":[]},"on_call_pager":"","pass_through":false,"sent_status":false,"unhealthy_interval":0,"webhooks":{"max_concurrent_requests":0,"url":""}}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/settings/application',
method: 'PATCH',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "callback_backoff_delay_ms": "",\n "callback_persist": false,\n "heartbeat_interval": 0,\n "max_callback_backoff_delay_ms": "",\n "media": {\n "auto_download": []\n },\n "on_call_pager": "",\n "pass_through": false,\n "sent_status": false,\n "unhealthy_interval": 0,\n "webhooks": {\n "max_concurrent_requests": 0,\n "url": ""\n }\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"callback_backoff_delay_ms\": \"\",\n \"callback_persist\": false,\n \"heartbeat_interval\": 0,\n \"max_callback_backoff_delay_ms\": \"\",\n \"media\": {\n \"auto_download\": []\n },\n \"on_call_pager\": \"\",\n \"pass_through\": false,\n \"sent_status\": false,\n \"unhealthy_interval\": 0,\n \"webhooks\": {\n \"max_concurrent_requests\": 0,\n \"url\": \"\"\n }\n}")
val request = Request.Builder()
.url("{{baseUrl}}/settings/application")
.patch(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/settings/application',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
callback_backoff_delay_ms: '',
callback_persist: false,
heartbeat_interval: 0,
max_callback_backoff_delay_ms: '',
media: {auto_download: []},
on_call_pager: '',
pass_through: false,
sent_status: false,
unhealthy_interval: 0,
webhooks: {max_concurrent_requests: 0, url: ''}
}));
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/settings/application',
headers: {'content-type': 'application/json'},
body: {
callback_backoff_delay_ms: '',
callback_persist: false,
heartbeat_interval: 0,
max_callback_backoff_delay_ms: '',
media: {auto_download: []},
on_call_pager: '',
pass_through: false,
sent_status: false,
unhealthy_interval: 0,
webhooks: {max_concurrent_requests: 0, url: ''}
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/settings/application');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
callback_backoff_delay_ms: '',
callback_persist: false,
heartbeat_interval: 0,
max_callback_backoff_delay_ms: '',
media: {
auto_download: []
},
on_call_pager: '',
pass_through: false,
sent_status: false,
unhealthy_interval: 0,
webhooks: {
max_concurrent_requests: 0,
url: ''
}
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/settings/application',
headers: {'content-type': 'application/json'},
data: {
callback_backoff_delay_ms: '',
callback_persist: false,
heartbeat_interval: 0,
max_callback_backoff_delay_ms: '',
media: {auto_download: []},
on_call_pager: '',
pass_through: false,
sent_status: false,
unhealthy_interval: 0,
webhooks: {max_concurrent_requests: 0, url: ''}
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/settings/application';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"callback_backoff_delay_ms":"","callback_persist":false,"heartbeat_interval":0,"max_callback_backoff_delay_ms":"","media":{"auto_download":[]},"on_call_pager":"","pass_through":false,"sent_status":false,"unhealthy_interval":0,"webhooks":{"max_concurrent_requests":0,"url":""}}'
};
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/json" };
NSDictionary *parameters = @{ @"callback_backoff_delay_ms": @"",
@"callback_persist": @NO,
@"heartbeat_interval": @0,
@"max_callback_backoff_delay_ms": @"",
@"media": @{ @"auto_download": @[ ] },
@"on_call_pager": @"",
@"pass_through": @NO,
@"sent_status": @NO,
@"unhealthy_interval": @0,
@"webhooks": @{ @"max_concurrent_requests": @0, @"url": @"" } };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/settings/application"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/settings/application" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"callback_backoff_delay_ms\": \"\",\n \"callback_persist\": false,\n \"heartbeat_interval\": 0,\n \"max_callback_backoff_delay_ms\": \"\",\n \"media\": {\n \"auto_download\": []\n },\n \"on_call_pager\": \"\",\n \"pass_through\": false,\n \"sent_status\": false,\n \"unhealthy_interval\": 0,\n \"webhooks\": {\n \"max_concurrent_requests\": 0,\n \"url\": \"\"\n }\n}" in
Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/settings/application",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
CURLOPT_POSTFIELDS => json_encode([
'callback_backoff_delay_ms' => '',
'callback_persist' => null,
'heartbeat_interval' => 0,
'max_callback_backoff_delay_ms' => '',
'media' => [
'auto_download' => [
]
],
'on_call_pager' => '',
'pass_through' => null,
'sent_status' => null,
'unhealthy_interval' => 0,
'webhooks' => [
'max_concurrent_requests' => 0,
'url' => ''
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/settings/application', [
'body' => '{
"callback_backoff_delay_ms": "",
"callback_persist": false,
"heartbeat_interval": 0,
"max_callback_backoff_delay_ms": "",
"media": {
"auto_download": []
},
"on_call_pager": "",
"pass_through": false,
"sent_status": false,
"unhealthy_interval": 0,
"webhooks": {
"max_concurrent_requests": 0,
"url": ""
}
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/settings/application');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'callback_backoff_delay_ms' => '',
'callback_persist' => null,
'heartbeat_interval' => 0,
'max_callback_backoff_delay_ms' => '',
'media' => [
'auto_download' => [
]
],
'on_call_pager' => '',
'pass_through' => null,
'sent_status' => null,
'unhealthy_interval' => 0,
'webhooks' => [
'max_concurrent_requests' => 0,
'url' => ''
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'callback_backoff_delay_ms' => '',
'callback_persist' => null,
'heartbeat_interval' => 0,
'max_callback_backoff_delay_ms' => '',
'media' => [
'auto_download' => [
]
],
'on_call_pager' => '',
'pass_through' => null,
'sent_status' => null,
'unhealthy_interval' => 0,
'webhooks' => [
'max_concurrent_requests' => 0,
'url' => ''
]
]));
$request->setRequestUrl('{{baseUrl}}/settings/application');
$request->setRequestMethod('PATCH');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/settings/application' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"callback_backoff_delay_ms": "",
"callback_persist": false,
"heartbeat_interval": 0,
"max_callback_backoff_delay_ms": "",
"media": {
"auto_download": []
},
"on_call_pager": "",
"pass_through": false,
"sent_status": false,
"unhealthy_interval": 0,
"webhooks": {
"max_concurrent_requests": 0,
"url": ""
}
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/settings/application' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"callback_backoff_delay_ms": "",
"callback_persist": false,
"heartbeat_interval": 0,
"max_callback_backoff_delay_ms": "",
"media": {
"auto_download": []
},
"on_call_pager": "",
"pass_through": false,
"sent_status": false,
"unhealthy_interval": 0,
"webhooks": {
"max_concurrent_requests": 0,
"url": ""
}
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"callback_backoff_delay_ms\": \"\",\n \"callback_persist\": false,\n \"heartbeat_interval\": 0,\n \"max_callback_backoff_delay_ms\": \"\",\n \"media\": {\n \"auto_download\": []\n },\n \"on_call_pager\": \"\",\n \"pass_through\": false,\n \"sent_status\": false,\n \"unhealthy_interval\": 0,\n \"webhooks\": {\n \"max_concurrent_requests\": 0,\n \"url\": \"\"\n }\n}"
headers = { 'content-type': "application/json" }
conn.request("PATCH", "/baseUrl/settings/application", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/settings/application"
payload = {
"callback_backoff_delay_ms": "",
"callback_persist": False,
"heartbeat_interval": 0,
"max_callback_backoff_delay_ms": "",
"media": { "auto_download": [] },
"on_call_pager": "",
"pass_through": False,
"sent_status": False,
"unhealthy_interval": 0,
"webhooks": {
"max_concurrent_requests": 0,
"url": ""
}
}
headers = {"content-type": "application/json"}
response = requests.patch(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/settings/application"
payload <- "{\n \"callback_backoff_delay_ms\": \"\",\n \"callback_persist\": false,\n \"heartbeat_interval\": 0,\n \"max_callback_backoff_delay_ms\": \"\",\n \"media\": {\n \"auto_download\": []\n },\n \"on_call_pager\": \"\",\n \"pass_through\": false,\n \"sent_status\": false,\n \"unhealthy_interval\": 0,\n \"webhooks\": {\n \"max_concurrent_requests\": 0,\n \"url\": \"\"\n }\n}"
encode <- "json"
response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/settings/application")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"callback_backoff_delay_ms\": \"\",\n \"callback_persist\": false,\n \"heartbeat_interval\": 0,\n \"max_callback_backoff_delay_ms\": \"\",\n \"media\": {\n \"auto_download\": []\n },\n \"on_call_pager\": \"\",\n \"pass_through\": false,\n \"sent_status\": false,\n \"unhealthy_interval\": 0,\n \"webhooks\": {\n \"max_concurrent_requests\": 0,\n \"url\": \"\"\n }\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.patch('/baseUrl/settings/application') do |req|
req.body = "{\n \"callback_backoff_delay_ms\": \"\",\n \"callback_persist\": false,\n \"heartbeat_interval\": 0,\n \"max_callback_backoff_delay_ms\": \"\",\n \"media\": {\n \"auto_download\": []\n },\n \"on_call_pager\": \"\",\n \"pass_through\": false,\n \"sent_status\": false,\n \"unhealthy_interval\": 0,\n \"webhooks\": {\n \"max_concurrent_requests\": 0,\n \"url\": \"\"\n }\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/settings/application";
let payload = json!({
"callback_backoff_delay_ms": "",
"callback_persist": false,
"heartbeat_interval": 0,
"max_callback_backoff_delay_ms": "",
"media": json!({"auto_download": ()}),
"on_call_pager": "",
"pass_through": false,
"sent_status": false,
"unhealthy_interval": 0,
"webhooks": json!({
"max_concurrent_requests": 0,
"url": ""
})
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/settings/application \
--header 'content-type: application/json' \
--data '{
"callback_backoff_delay_ms": "",
"callback_persist": false,
"heartbeat_interval": 0,
"max_callback_backoff_delay_ms": "",
"media": {
"auto_download": []
},
"on_call_pager": "",
"pass_through": false,
"sent_status": false,
"unhealthy_interval": 0,
"webhooks": {
"max_concurrent_requests": 0,
"url": ""
}
}'echo '{
"callback_backoff_delay_ms": "",
"callback_persist": false,
"heartbeat_interval": 0,
"max_callback_backoff_delay_ms": "",
"media": {
"auto_download": []
},
"on_call_pager": "",
"pass_through": false,
"sent_status": false,
"unhealthy_interval": 0,
"webhooks": {
"max_concurrent_requests": 0,
"url": ""
}
}' | \
http PATCH {{baseUrl}}/settings/application \
content-type:application/jsonwget --quiet \
--method PATCH \
--header 'content-type: application/json' \
--body-data '{\n "callback_backoff_delay_ms": "",\n "callback_persist": false,\n "heartbeat_interval": 0,\n "max_callback_backoff_delay_ms": "",\n "media": {\n "auto_download": []\n },\n "on_call_pager": "",\n "pass_through": false,\n "sent_status": false,\n "unhealthy_interval": 0,\n "webhooks": {\n "max_concurrent_requests": 0,\n "url": ""\n }\n}' \
--output-document \
- {{baseUrl}}/settings/applicationimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"callback_backoff_delay_ms": "",
"callback_persist": false,
"heartbeat_interval": 0,
"max_callback_backoff_delay_ms": "",
"media": ["auto_download": []],
"on_call_pager": "",
"pass_through": false,
"sent_status": false,
"unhealthy_interval": 0,
"webhooks": [
"max_concurrent_requests": 0,
"url": ""
]
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/settings/application")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"errors": [
{
"code": 1234,
"details": "optional-detailed-error-message",
"title": "error-code-title"
}
],
"meta": {
"api_status": "deprecated",
"version": "whatsapp-business-api-client-version"
}
}
POST
Update-Media-Providers
{{baseUrl}}/settings/application/media/providers
BODY json
[
{
"config": "",
"name": "",
"type": ""
}
]
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/settings/application/media/providers");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "[\n {\n \"config\": {\n \"bearer\": \"\"\n },\n \"name\": \"\",\n \"type\": \"www\"\n }\n]");
CURLcode ret = curl_easy_perform(hnd); (require '[clj-http.client :as client])
(client/post "{{baseUrl}}/settings/application/media/providers" {:content-type :json
:form-params [{:config {:bearer ""}
:name ""
:type "www"}]}) require "http/client"
url = "{{baseUrl}}/settings/application/media/providers"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "[\n {\n \"config\": {\n \"bearer\": \"\"\n },\n \"name\": \"\",\n \"type\": \"www\"\n }\n]"
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}}/settings/application/media/providers"),
Content = new StringContent("[\n {\n \"config\": {\n \"bearer\": \"\"\n },\n \"name\": \"\",\n \"type\": \"www\"\n }\n]")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
} var client = new RestClient("{{baseUrl}}/settings/application/media/providers");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n {\n \"config\": {\n \"bearer\": \"\"\n },\n \"name\": \"\",\n \"type\": \"www\"\n }\n]", ParameterType.RequestBody);
var response = client.Execute(request); package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/settings/application/media/providers"
payload := strings.NewReader("[\n {\n \"config\": {\n \"bearer\": \"\"\n },\n \"name\": \"\",\n \"type\": \"www\"\n }\n]")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
} POST /baseUrl/settings/application/media/providers HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 121
[
{
"config": {
"bearer": ""
},
"name": "",
"type": "www"
}
] AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/settings/application/media/providers")
.setHeader("content-type", "application/json")
.setBody("[\n {\n \"config\": {\n \"bearer\": \"\"\n },\n \"name\": \"\",\n \"type\": \"www\"\n }\n]")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close(); HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/settings/application/media/providers"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("[\n {\n \"config\": {\n \"bearer\": \"\"\n },\n \"name\": \"\",\n \"type\": \"www\"\n }\n]"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "[\n {\n \"config\": {\n \"bearer\": \"\"\n },\n \"name\": \"\",\n \"type\": \"www\"\n }\n]");
Request request = new Request.Builder()
.url("{{baseUrl}}/settings/application/media/providers")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute(); HttpResponse response = Unirest.post("{{baseUrl}}/settings/application/media/providers")
.header("content-type", "application/json")
.body("[\n {\n \"config\": {\n \"bearer\": \"\"\n },\n \"name\": \"\",\n \"type\": \"www\"\n }\n]")
.asString(); const data = JSON.stringify([
{
config: {
bearer: ''
},
name: '',
type: 'www'
}
]);
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/settings/application/media/providers');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data); import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/settings/application/media/providers',
headers: {'content-type': 'application/json'},
data: [
{config: {bearer: ''}, name: '', type: 'www'}
]
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
} const url = '{{baseUrl}}/settings/application/media/providers';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '[{"config":{"bearer":""},"name":"","type":"www"}]'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
} const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/settings/application/media/providers',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '[\n {\n "config": {\n "bearer": ""\n },\n "name": "",\n "type": "www"\n }\n]'
};
$.ajax(settings).done(function (response) {
console.log(response);
}); val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "[\n {\n \"config\": {\n \"bearer\": \"\"\n },\n \"name\": \"\",\n \"type\": \"www\"\n }\n]")
val request = Request.Builder()
.url("{{baseUrl}}/settings/application/media/providers")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute() const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/settings/application/media/providers',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify([
{config: {bearer: ''}, name: '', type: 'www'}
]));
req.end(); const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/settings/application/media/providers',
headers: {'content-type': 'application/json'},
body: [
{config: {bearer: ''}, name: '', type: 'www'}
],
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
}); const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/settings/application/media/providers');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send([
{
config: {
bearer: ''
},
name: '',
type: 'www'
}
]);
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}}/settings/application/media/providers',
headers: {'content-type': 'application/json'},
data: [
{config: {bearer: ''}, name: '', type: 'www'}
]
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
} const fetch = require('node-fetch');
const url = '{{baseUrl}}/settings/application/media/providers';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '[{"config":{"bearer":""},"name":"","type":"www"}]'
};
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/json" };
NSDictionary *parameters = @[ @{ @"config": @{ @"bearer": @"" }, @"name": @"", @"type": @"www" } ];
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/settings/application/media/providers"]
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}}/settings/application/media/providers" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n {\n \"config\": {\n \"bearer\": \"\"\n },\n \"name\": \"\",\n \"type\": \"www\"\n }\n]" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/settings/application/media/providers",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
[
'config' => [
'bearer' => ''
],
'name' => '',
'type' => 'www'
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
} request('POST', '{{baseUrl}}/settings/application/media/providers', [
'body' => '[
{
"config": {
"bearer": ""
},
"name": "",
"type": "www"
}
]',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody(); setUrl('{{baseUrl}}/settings/application/media/providers');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
[
'config' => [
'bearer' => ''
],
'name' => '',
'type' => 'www'
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
} append(json_encode([
[
'config' => [
'bearer' => ''
],
'name' => '',
'type' => 'www'
]
]));
$request->setRequestUrl('{{baseUrl}}/settings/application/media/providers');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody(); $headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/settings/application/media/providers' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
{
"config": {
"bearer": ""
},
"name": "",
"type": "www"
}
]' $headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/settings/application/media/providers' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
{
"config": {
"bearer": ""
},
"name": "",
"type": "www"
}
]' import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "[\n {\n \"config\": {\n \"bearer\": \"\"\n },\n \"name\": \"\",\n \"type\": \"www\"\n }\n]"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/settings/application/media/providers", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8")) import requests
url = "{{baseUrl}}/settings/application/media/providers"
payload = [
{
"config": { "bearer": "" },
"name": "",
"type": "www"
}
]
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json()) library(httr)
url <- "{{baseUrl}}/settings/application/media/providers"
payload <- "[\n {\n \"config\": {\n \"bearer\": \"\"\n },\n \"name\": \"\",\n \"type\": \"www\"\n }\n]"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text") require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/settings/application/media/providers")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "[\n {\n \"config\": {\n \"bearer\": \"\"\n },\n \"name\": \"\",\n \"type\": \"www\"\n }\n]"
response = http.request(request)
puts response.read_body require 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/settings/application/media/providers') do |req|
req.body = "[\n {\n \"config\": {\n \"bearer\": \"\"\n },\n \"name\": \"\",\n \"type\": \"www\"\n }\n]"
end
puts response.status
puts response.body use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/settings/application/media/providers";
let payload = (
json!({
"config": json!({"bearer": ""}),
"name": "",
"type": "www"
})
);
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/settings/application/media/providers \
--header 'content-type: application/json' \
--data '[
{
"config": {
"bearer": ""
},
"name": "",
"type": "www"
}
]' echo '[
{
"config": {
"bearer": ""
},
"name": "",
"type": "www"
}
]' | \
http POST {{baseUrl}}/settings/application/media/providers \
content-type:application/json wget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '[\n {\n "config": {\n "bearer": ""\n },\n "name": "",\n "type": "www"\n }\n]' \
--output-document \
- {{baseUrl}}/settings/application/media/providers import Foundation
let headers = ["content-type": "application/json"]
let parameters = [
[
"config": ["bearer": ""],
"name": "",
"type": "www"
]
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/settings/application/media/providers")! 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
Backup-Settings
{{baseUrl}}/settings/backup
BODY json
{
"password": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/settings/backup");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"password\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/settings/backup" {:content-type :json
:form-params {:password ""}})require "http/client"
url = "{{baseUrl}}/settings/backup"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"password\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/settings/backup"),
Content = new StringContent("{\n \"password\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/settings/backup");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"password\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/settings/backup"
payload := strings.NewReader("{\n \"password\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/settings/backup HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20
{
"password": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/settings/backup")
.setHeader("content-type", "application/json")
.setBody("{\n \"password\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/settings/backup"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"password\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"password\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/settings/backup")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/settings/backup")
.header("content-type", "application/json")
.body("{\n \"password\": \"\"\n}")
.asString(); const data = JSON.stringify({
password: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/settings/backup');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/settings/backup',
headers: {'content-type': 'application/json'},
data: {password: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/settings/backup';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"password":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/settings/backup',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "password": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"password\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/settings/backup")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/settings/backup',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({password: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/settings/backup',
headers: {'content-type': 'application/json'},
body: {password: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/settings/backup');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
password: ''
});
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}}/settings/backup',
headers: {'content-type': 'application/json'},
data: {password: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/settings/backup';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"password":""}'
};
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/json" };
NSDictionary *parameters = @{ @"password": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/settings/backup"]
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}}/settings/backup" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"password\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/settings/backup",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'password' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/settings/backup', [
'body' => '{
"password": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/settings/backup');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'password' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'password' => ''
]));
$request->setRequestUrl('{{baseUrl}}/settings/backup');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/settings/backup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"password": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/settings/backup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"password": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"password\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/settings/backup", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/settings/backup"
payload = { "password": "" }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/settings/backup"
payload <- "{\n \"password\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/settings/backup")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"password\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/settings/backup') do |req|
req.body = "{\n \"password\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/settings/backup";
let payload = json!({"password": ""});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/settings/backup \
--header 'content-type: application/json' \
--data '{
"password": ""
}'echo '{
"password": ""
}' | \
http POST {{baseUrl}}/settings/backup \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "password": ""\n}' \
--output-document \
- {{baseUrl}}/settings/backupimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["password": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/settings/backup")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"settings": {
"data": "encrypted-backup-data"
}
}
POST
Restore-Settings
{{baseUrl}}/settings/restore
BODY json
{
"data": "",
"password": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/settings/restore");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"data\": \"\",\n \"password\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd); (require '[clj-http.client :as client])
(client/post "{{baseUrl}}/settings/restore" {:content-type :json
:form-params {:data ""
:password ""}}) require "http/client"
url = "{{baseUrl}}/settings/restore"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"data\": \"\",\n \"password\": \"\"\n}"
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}}/settings/restore"),
Content = new StringContent("{\n \"data\": \"\",\n \"password\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
} var client = new RestClient("{{baseUrl}}/settings/restore");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"data\": \"\",\n \"password\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request); package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/settings/restore"
payload := strings.NewReader("{\n \"data\": \"\",\n \"password\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
} POST /baseUrl/settings/restore HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 89
{
"data": "",
"password": ""
} AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/settings/restore")
.setHeader("content-type", "application/json")
.setBody("{\n \"data\": \"\",\n \"password\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close(); HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/settings/restore"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"data\": \"\",\n \"password\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"data\": \"\",\n \"password\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/settings/restore")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute(); HttpResponse response = Unirest.post("{{baseUrl}}/settings/restore")
.header("content-type", "application/json")
.body("{\n \"data\": \"\",\n \"password\": \"\"\n}")
.asString(); const data = JSON.stringify({
data: '',
password: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/settings/restore');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data); import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/settings/restore',
headers: {'content-type': 'application/json'},
data: {data: '', password: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
} const url = '{{baseUrl}}/settings/restore';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"data":"","password":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
} const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/settings/restore',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "data": "",\n "password": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
}); val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"data\": \"\",\n \"password\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/settings/restore")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute() const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/settings/restore',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({data: '', password: ''}));
req.end(); const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/settings/restore',
headers: {'content-type': 'application/json'},
body: {data: '', password: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
}); const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/settings/restore');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
data: '',
password: ''
});
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}}/settings/restore',
headers: {'content-type': 'application/json'},
data: {data: '', password: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
} const fetch = require('node-fetch');
const url = '{{baseUrl}}/settings/restore';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"data":"","password":""}'
};
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/json" };
NSDictionary *parameters = @{ @"data": @"",
@"password": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/settings/restore"]
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}}/settings/restore" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"data\": \"\",\n \"password\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/settings/restore",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'data' => '',
'password' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
} request('POST', '{{baseUrl}}/settings/restore', [
'body' => '{
"data": "",
"password": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody(); setUrl('{{baseUrl}}/settings/restore');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'data' => '',
'password' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
} append(json_encode([
'data' => '',
'password' => ''
]));
$request->setRequestUrl('{{baseUrl}}/settings/restore');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody(); $headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/settings/restore' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"data": "",
"password": ""
}' $headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/settings/restore' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"data": "",
"password": ""
}' import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"data\": \"\",\n \"password\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/settings/restore", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8")) import requests
url = "{{baseUrl}}/settings/restore"
payload = {
"data": "",
"password": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json()) library(httr)
url <- "{{baseUrl}}/settings/restore"
payload <- "{\n \"data\": \"\",\n \"password\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text") require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/settings/restore")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"data\": \"\",\n \"password\": \"\"\n}"
response = http.request(request)
puts response.read_body require 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/settings/restore') do |req|
req.body = "{\n \"data\": \"\",\n \"password\": \"\"\n}"
end
puts response.status
puts response.body use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/settings/restore";
let payload = json!({
"data": "",
"password": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/settings/restore \
--header 'content-type: application/json' \
--data '{
"data": "",
"password": ""
}' echo '{
"data": "",
"password": ""
}' | \
http POST {{baseUrl}}/settings/restore \
content-type:application/json wget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "data": "",\n "password": ""\n}' \
--output-document \
- {{baseUrl}}/settings/restore import Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"data": "",
"password": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/settings/restore")! 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
Get-Business-Profile
{{baseUrl}}/settings/business/profile
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/settings/business/profile");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/settings/business/profile")require "http/client"
url = "{{baseUrl}}/settings/business/profile"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/settings/business/profile"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/settings/business/profile");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/settings/business/profile"
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/settings/business/profile HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/settings/business/profile")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/settings/business/profile"))
.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}}/settings/business/profile")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/settings/business/profile")
.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}}/settings/business/profile');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/settings/business/profile'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/settings/business/profile';
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}}/settings/business/profile',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/settings/business/profile")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/settings/business/profile',
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}}/settings/business/profile'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/settings/business/profile');
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}}/settings/business/profile'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/settings/business/profile';
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}}/settings/business/profile"]
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}}/settings/business/profile" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/settings/business/profile",
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}}/settings/business/profile');
echo $response->getBody();setUrl('{{baseUrl}}/settings/business/profile');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/settings/business/profile');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/settings/business/profile' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/settings/business/profile' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/settings/business/profile")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/settings/business/profile"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/settings/business/profile"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/settings/business/profile")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/settings/business/profile') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/settings/business/profile";
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}}/settings/business/profilehttp GET {{baseUrl}}/settings/business/profilewget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/settings/business/profileimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/settings/business/profile")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"settings": {
"business": {
"profile": {
"address": "new-business-address",
"description": "business-description",
"email": "new-business-email",
"vertical": "business-industry",
"websites": [
"website-1",
"website-2"
]
}
}
}
}
POST
Update-Business-Profile
{{baseUrl}}/settings/business/profile
BODY json
{
"address": "",
"description": "",
"email": "",
"vertical": "",
"websites": []
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/settings/business/profile");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"address\": \"\",\n \"description\": \"\",\n \"email\": \"\",\n \"vertical\": \"\",\n \"websites\": [\n \"https://www.whatsapp.com\",\n \"https://www.facebook.com\"\n ]\n}");
CURLcode ret = curl_easy_perform(hnd); (require '[clj-http.client :as client])
(client/post "{{baseUrl}}/settings/business/profile" {:content-type :json
:form-params {:address ""
:description ""
:email ""
:vertical ""
:websites ["https://www.whatsapp.com" "https://www.facebook.com"]}}) require "http/client"
url = "{{baseUrl}}/settings/business/profile"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"address\": \"\",\n \"description\": \"\",\n \"email\": \"\",\n \"vertical\": \"\",\n \"websites\": [\n \"https://www.whatsapp.com\",\n \"https://www.facebook.com\"\n ]\n}"
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}}/settings/business/profile"),
Content = new StringContent("{\n \"address\": \"\",\n \"description\": \"\",\n \"email\": \"\",\n \"vertical\": \"\",\n \"websites\": [\n \"https://www.whatsapp.com\",\n \"https://www.facebook.com\"\n ]\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
} var client = new RestClient("{{baseUrl}}/settings/business/profile");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"address\": \"\",\n \"description\": \"\",\n \"email\": \"\",\n \"vertical\": \"\",\n \"websites\": [\n \"https://www.whatsapp.com\",\n \"https://www.facebook.com\"\n ]\n}", ParameterType.RequestBody);
var response = client.Execute(request); package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/settings/business/profile"
payload := strings.NewReader("{\n \"address\": \"\",\n \"description\": \"\",\n \"email\": \"\",\n \"vertical\": \"\",\n \"websites\": [\n \"https://www.whatsapp.com\",\n \"https://www.facebook.com\"\n ]\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
} POST /baseUrl/settings/business/profile HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 264
{
"address": "",
"description": "",
"email": "",
"vertical": "",
"websites": [
"https://www.whatsapp.com",
"https://www.facebook.com"
]
} AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/settings/business/profile")
.setHeader("content-type", "application/json")
.setBody("{\n \"address\": \"\",\n \"description\": \"\",\n \"email\": \"\",\n \"vertical\": \"\",\n \"websites\": [\n \"https://www.whatsapp.com\",\n \"https://www.facebook.com\"\n ]\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close(); HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/settings/business/profile"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"address\": \"\",\n \"description\": \"\",\n \"email\": \"\",\n \"vertical\": \"\",\n \"websites\": [\n \"https://www.whatsapp.com\",\n \"https://www.facebook.com\"\n ]\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"address\": \"\",\n \"description\": \"\",\n \"email\": \"\",\n \"vertical\": \"\",\n \"websites\": [\n \"https://www.whatsapp.com\",\n \"https://www.facebook.com\"\n ]\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/settings/business/profile")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute(); HttpResponse response = Unirest.post("{{baseUrl}}/settings/business/profile")
.header("content-type", "application/json")
.body("{\n \"address\": \"\",\n \"description\": \"\",\n \"email\": \"\",\n \"vertical\": \"\",\n \"websites\": [\n \"https://www.whatsapp.com\",\n \"https://www.facebook.com\"\n ]\n}")
.asString(); const data = JSON.stringify({
address: '',
description: '',
email: '',
vertical: '',
websites: [
'https://www.whatsapp.com',
'https://www.facebook.com'
]
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/settings/business/profile');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data); import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/settings/business/profile',
headers: {'content-type': 'application/json'},
data: {
address: '',
description: '',
email: '',
vertical: '',
websites: ['https://www.whatsapp.com', 'https://www.facebook.com']
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
} const url = '{{baseUrl}}/settings/business/profile';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"address":"","description":"","email":"","vertical":"","websites":["https://www.whatsapp.com","https://www.facebook.com"]}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
} const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/settings/business/profile',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "address": "",\n "description": "",\n "email": "",\n "vertical": "",\n "websites": [\n "https://www.whatsapp.com",\n "https://www.facebook.com"\n ]\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
}); val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"address\": \"\",\n \"description\": \"\",\n \"email\": \"\",\n \"vertical\": \"\",\n \"websites\": [\n \"https://www.whatsapp.com\",\n \"https://www.facebook.com\"\n ]\n}")
val request = Request.Builder()
.url("{{baseUrl}}/settings/business/profile")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute() const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/settings/business/profile',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
address: '',
description: '',
email: '',
vertical: '',
websites: ['https://www.whatsapp.com', 'https://www.facebook.com']
}));
req.end(); const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/settings/business/profile',
headers: {'content-type': 'application/json'},
body: {
address: '',
description: '',
email: '',
vertical: '',
websites: ['https://www.whatsapp.com', 'https://www.facebook.com']
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
}); const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/settings/business/profile');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
address: '',
description: '',
email: '',
vertical: '',
websites: [
'https://www.whatsapp.com',
'https://www.facebook.com'
]
});
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}}/settings/business/profile',
headers: {'content-type': 'application/json'},
data: {
address: '',
description: '',
email: '',
vertical: '',
websites: ['https://www.whatsapp.com', 'https://www.facebook.com']
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
} const fetch = require('node-fetch');
const url = '{{baseUrl}}/settings/business/profile';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"address":"","description":"","email":"","vertical":"","websites":["https://www.whatsapp.com","https://www.facebook.com"]}'
};
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/json" };
NSDictionary *parameters = @{ @"address": @"",
@"description": @"",
@"email": @"",
@"vertical": @"",
@"websites": @[ @"https://www.whatsapp.com", @"https://www.facebook.com" ] };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/settings/business/profile"]
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}}/settings/business/profile" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"address\": \"\",\n \"description\": \"\",\n \"email\": \"\",\n \"vertical\": \"\",\n \"websites\": [\n \"https://www.whatsapp.com\",\n \"https://www.facebook.com\"\n ]\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/settings/business/profile",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'address' => '',
'description' => '',
'email' => '',
'vertical' => '',
'websites' => [
'https://www.whatsapp.com',
'https://www.facebook.com'
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
} request('POST', '{{baseUrl}}/settings/business/profile', [
'body' => '{
"address": "",
"description": "",
"email": "",
"vertical": "",
"websites": [
"https://www.whatsapp.com",
"https://www.facebook.com"
]
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody(); setUrl('{{baseUrl}}/settings/business/profile');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'address' => '',
'description' => '',
'email' => '',
'vertical' => '',
'websites' => [
'https://www.whatsapp.com',
'https://www.facebook.com'
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
} append(json_encode([
'address' => '',
'description' => '',
'email' => '',
'vertical' => '',
'websites' => [
'https://www.whatsapp.com',
'https://www.facebook.com'
]
]));
$request->setRequestUrl('{{baseUrl}}/settings/business/profile');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody(); $headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/settings/business/profile' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"address": "",
"description": "",
"email": "",
"vertical": "",
"websites": [
"https://www.whatsapp.com",
"https://www.facebook.com"
]
}' $headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/settings/business/profile' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"address": "",
"description": "",
"email": "",
"vertical": "",
"websites": [
"https://www.whatsapp.com",
"https://www.facebook.com"
]
}' import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"address\": \"\",\n \"description\": \"\",\n \"email\": \"\",\n \"vertical\": \"\",\n \"websites\": [\n \"https://www.whatsapp.com\",\n \"https://www.facebook.com\"\n ]\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/settings/business/profile", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8")) import requests
url = "{{baseUrl}}/settings/business/profile"
payload = {
"address": "",
"description": "",
"email": "",
"vertical": "",
"websites": ["https://www.whatsapp.com", "https://www.facebook.com"]
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json()) library(httr)
url <- "{{baseUrl}}/settings/business/profile"
payload <- "{\n \"address\": \"\",\n \"description\": \"\",\n \"email\": \"\",\n \"vertical\": \"\",\n \"websites\": [\n \"https://www.whatsapp.com\",\n \"https://www.facebook.com\"\n ]\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text") require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/settings/business/profile")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"address\": \"\",\n \"description\": \"\",\n \"email\": \"\",\n \"vertical\": \"\",\n \"websites\": [\n \"https://www.whatsapp.com\",\n \"https://www.facebook.com\"\n ]\n}"
response = http.request(request)
puts response.read_body require 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/settings/business/profile') do |req|
req.body = "{\n \"address\": \"\",\n \"description\": \"\",\n \"email\": \"\",\n \"vertical\": \"\",\n \"websites\": [\n \"https://www.whatsapp.com\",\n \"https://www.facebook.com\"\n ]\n}"
end
puts response.status
puts response.body use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/settings/business/profile";
let payload = json!({
"address": "",
"description": "",
"email": "",
"vertical": "",
"websites": ("https://www.whatsapp.com", "https://www.facebook.com")
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/settings/business/profile \
--header 'content-type: application/json' \
--data '{
"address": "",
"description": "",
"email": "",
"vertical": "",
"websites": [
"https://www.whatsapp.com",
"https://www.facebook.com"
]
}' echo '{
"address": "",
"description": "",
"email": "",
"vertical": "",
"websites": [
"https://www.whatsapp.com",
"https://www.facebook.com"
]
}' | \
http POST {{baseUrl}}/settings/business/profile \
content-type:application/json wget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "address": "",\n "description": "",\n "email": "",\n "vertical": "",\n "websites": [\n "https://www.whatsapp.com",\n "https://www.facebook.com"\n ]\n}' \
--output-document \
- {{baseUrl}}/settings/business/profile import Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"address": "",
"description": "",
"email": "",
"vertical": "",
"websites": ["https://www.whatsapp.com", "https://www.facebook.com"]
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/settings/business/profile")! 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 Webhook CA Certificate
{{baseUrl}}/certificates/webhooks/ca
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/certificates/webhooks/ca");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/certificates/webhooks/ca")require "http/client"
url = "{{baseUrl}}/certificates/webhooks/ca"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/certificates/webhooks/ca"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/certificates/webhooks/ca");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/certificates/webhooks/ca"
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/certificates/webhooks/ca HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/certificates/webhooks/ca")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/certificates/webhooks/ca"))
.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}}/certificates/webhooks/ca")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/certificates/webhooks/ca")
.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}}/certificates/webhooks/ca');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/certificates/webhooks/ca'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/certificates/webhooks/ca';
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}}/certificates/webhooks/ca',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/certificates/webhooks/ca")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/certificates/webhooks/ca',
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}}/certificates/webhooks/ca'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/certificates/webhooks/ca');
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}}/certificates/webhooks/ca'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/certificates/webhooks/ca';
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}}/certificates/webhooks/ca"]
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}}/certificates/webhooks/ca" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/certificates/webhooks/ca",
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}}/certificates/webhooks/ca');
echo $response->getBody();setUrl('{{baseUrl}}/certificates/webhooks/ca');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/certificates/webhooks/ca');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/certificates/webhooks/ca' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/certificates/webhooks/ca' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/certificates/webhooks/ca")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/certificates/webhooks/ca"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/certificates/webhooks/ca"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/certificates/webhooks/ca")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/certificates/webhooks/ca') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/certificates/webhooks/ca";
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}}/certificates/webhooks/cahttp DELETE {{baseUrl}}/certificates/webhooks/cawget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/certificates/webhooks/caimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/certificates/webhooks/ca")! 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
Download Webhook CA Certificate
{{baseUrl}}/certificates/webhooks/ca
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/certificates/webhooks/ca");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/certificates/webhooks/ca")require "http/client"
url = "{{baseUrl}}/certificates/webhooks/ca"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/certificates/webhooks/ca"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/certificates/webhooks/ca");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/certificates/webhooks/ca"
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/certificates/webhooks/ca HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/certificates/webhooks/ca")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/certificates/webhooks/ca"))
.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}}/certificates/webhooks/ca")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/certificates/webhooks/ca")
.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}}/certificates/webhooks/ca');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/certificates/webhooks/ca'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/certificates/webhooks/ca';
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}}/certificates/webhooks/ca',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/certificates/webhooks/ca")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/certificates/webhooks/ca',
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}}/certificates/webhooks/ca'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/certificates/webhooks/ca');
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}}/certificates/webhooks/ca'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/certificates/webhooks/ca';
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}}/certificates/webhooks/ca"]
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}}/certificates/webhooks/ca" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/certificates/webhooks/ca",
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}}/certificates/webhooks/ca');
echo $response->getBody();setUrl('{{baseUrl}}/certificates/webhooks/ca');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/certificates/webhooks/ca');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/certificates/webhooks/ca' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/certificates/webhooks/ca' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/certificates/webhooks/ca")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/certificates/webhooks/ca"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/certificates/webhooks/ca"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/certificates/webhooks/ca")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/certificates/webhooks/ca') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/certificates/webhooks/ca";
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}}/certificates/webhooks/cahttp GET {{baseUrl}}/certificates/webhooks/cawget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/certificates/webhooks/caimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/certificates/webhooks/ca")! 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
Download-CA-Certificate
{{baseUrl}}/certificates/external/ca
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/certificates/external/ca");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/certificates/external/ca")require "http/client"
url = "{{baseUrl}}/certificates/external/ca"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/certificates/external/ca"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/certificates/external/ca");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/certificates/external/ca"
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/certificates/external/ca HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/certificates/external/ca")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/certificates/external/ca"))
.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}}/certificates/external/ca")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/certificates/external/ca")
.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}}/certificates/external/ca');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/certificates/external/ca'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/certificates/external/ca';
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}}/certificates/external/ca',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/certificates/external/ca")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/certificates/external/ca',
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}}/certificates/external/ca'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/certificates/external/ca');
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}}/certificates/external/ca'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/certificates/external/ca';
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}}/certificates/external/ca"]
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}}/certificates/external/ca" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/certificates/external/ca",
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}}/certificates/external/ca');
echo $response->getBody();setUrl('{{baseUrl}}/certificates/external/ca');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/certificates/external/ca');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/certificates/external/ca' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/certificates/external/ca' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/certificates/external/ca")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/certificates/external/ca"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/certificates/external/ca"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/certificates/external/ca")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/certificates/external/ca') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/certificates/external/ca";
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}}/certificates/external/cahttp GET {{baseUrl}}/certificates/external/cawget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/certificates/external/caimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/certificates/external/ca")! 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
Upload Webhook CA Certificate
{{baseUrl}}/certificates/webhooks/ca
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/certificates/webhooks/ca");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/certificates/webhooks/ca")require "http/client"
url = "{{baseUrl}}/certificates/webhooks/ca"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/certificates/webhooks/ca"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/certificates/webhooks/ca");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/certificates/webhooks/ca"
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/certificates/webhooks/ca HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/certificates/webhooks/ca")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/certificates/webhooks/ca"))
.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}}/certificates/webhooks/ca")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/certificates/webhooks/ca")
.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}}/certificates/webhooks/ca');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/certificates/webhooks/ca'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/certificates/webhooks/ca';
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}}/certificates/webhooks/ca',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/certificates/webhooks/ca")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/certificates/webhooks/ca',
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}}/certificates/webhooks/ca'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/certificates/webhooks/ca');
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}}/certificates/webhooks/ca'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/certificates/webhooks/ca';
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}}/certificates/webhooks/ca"]
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}}/certificates/webhooks/ca" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/certificates/webhooks/ca",
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}}/certificates/webhooks/ca');
echo $response->getBody();setUrl('{{baseUrl}}/certificates/webhooks/ca');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/certificates/webhooks/ca');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/certificates/webhooks/ca' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/certificates/webhooks/ca' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/certificates/webhooks/ca")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/certificates/webhooks/ca"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/certificates/webhooks/ca"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/certificates/webhooks/ca")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/certificates/webhooks/ca') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/certificates/webhooks/ca";
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}}/certificates/webhooks/cahttp POST {{baseUrl}}/certificates/webhooks/cawget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/certificates/webhooks/caimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/certificates/webhooks/ca")! 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()
POST
Upload-Certificate
{{baseUrl}}/certificates/external
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/certificates/external");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/certificates/external")require "http/client"
url = "{{baseUrl}}/certificates/external"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/certificates/external"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/certificates/external");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/certificates/external"
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/certificates/external HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/certificates/external")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/certificates/external"))
.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}}/certificates/external")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/certificates/external")
.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}}/certificates/external');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/certificates/external'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/certificates/external';
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}}/certificates/external',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/certificates/external")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/certificates/external',
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}}/certificates/external'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/certificates/external');
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}}/certificates/external'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/certificates/external';
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}}/certificates/external"]
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}}/certificates/external" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/certificates/external",
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}}/certificates/external');
echo $response->getBody();setUrl('{{baseUrl}}/certificates/external');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/certificates/external');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/certificates/external' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/certificates/external' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/certificates/external")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/certificates/external"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/certificates/external"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/certificates/external")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/certificates/external') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/certificates/external";
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}}/certificates/externalhttp POST {{baseUrl}}/certificates/externalwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/certificates/externalimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/certificates/external")! 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()
POST
Check-Contact
{{baseUrl}}/contacts
BODY json
{
"blocking": "",
"contacts": []
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contacts");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"blocking\": \"\",\n \"contacts\": []\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/contacts" {:content-type :json
:form-params {:blocking ""
:contacts []}})require "http/client"
url = "{{baseUrl}}/contacts"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"blocking\": \"\",\n \"contacts\": []\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/contacts"),
Content = new StringContent("{\n \"blocking\": \"\",\n \"contacts\": []\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/contacts");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"blocking\": \"\",\n \"contacts\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/contacts"
payload := strings.NewReader("{\n \"blocking\": \"\",\n \"contacts\": []\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/contacts HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 38
{
"blocking": "",
"contacts": []
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contacts")
.setHeader("content-type", "application/json")
.setBody("{\n \"blocking\": \"\",\n \"contacts\": []\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/contacts"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"blocking\": \"\",\n \"contacts\": []\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"blocking\": \"\",\n \"contacts\": []\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/contacts")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/contacts")
.header("content-type", "application/json")
.body("{\n \"blocking\": \"\",\n \"contacts\": []\n}")
.asString(); const data = JSON.stringify({
blocking: '',
contacts: []
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/contacts');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/contacts',
headers: {'content-type': 'application/json'},
data: {blocking: '', contacts: []}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/contacts';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"blocking":"","contacts":[]}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/contacts',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "blocking": "",\n "contacts": []\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"blocking\": \"\",\n \"contacts\": []\n}")
val request = Request.Builder()
.url("{{baseUrl}}/contacts")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/contacts',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({blocking: '', contacts: []}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/contacts',
headers: {'content-type': 'application/json'},
body: {blocking: '', contacts: []},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/contacts');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
blocking: '',
contacts: []
});
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}}/contacts',
headers: {'content-type': 'application/json'},
data: {blocking: '', contacts: []}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/contacts';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"blocking":"","contacts":[]}'
};
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/json" };
NSDictionary *parameters = @{ @"blocking": @"",
@"contacts": @[ ] };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contacts"]
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}}/contacts" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"blocking\": \"\",\n \"contacts\": []\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/contacts",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'blocking' => '',
'contacts' => [
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/contacts', [
'body' => '{
"blocking": "",
"contacts": []
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/contacts');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'blocking' => '',
'contacts' => [
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'blocking' => '',
'contacts' => [
]
]));
$request->setRequestUrl('{{baseUrl}}/contacts');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contacts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"blocking": "",
"contacts": []
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contacts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"blocking": "",
"contacts": []
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"blocking\": \"\",\n \"contacts\": []\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/contacts", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/contacts"
payload = {
"blocking": "",
"contacts": []
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/contacts"
payload <- "{\n \"blocking\": \"\",\n \"contacts\": []\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/contacts")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"blocking\": \"\",\n \"contacts\": []\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/contacts') do |req|
req.body = "{\n \"blocking\": \"\",\n \"contacts\": []\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/contacts";
let payload = json!({
"blocking": "",
"contacts": ()
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/contacts \
--header 'content-type: application/json' \
--data '{
"blocking": "",
"contacts": []
}'echo '{
"blocking": "",
"contacts": []
}' | \
http POST {{baseUrl}}/contacts \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "blocking": "",\n "contacts": []\n}' \
--output-document \
- {{baseUrl}}/contactsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"blocking": "",
"contacts": []
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contacts")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"contacts": [
{
"input": "1-631-555-1002",
"status": "processing"
},
{
"input": "6315551003",
"status": "processing"
},
{
"input": "+54 9 11 5612-1008",
"status": "processing"
},
{
"input": "+1 (516) 283-7151",
"status": "valid",
"wa_id": "15162837151"
}
]
}
POST
Create-Group
{{baseUrl}}/groups
BODY json
{
"subject": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"subject\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/groups" {:content-type :json
:form-params {:subject ""}})require "http/client"
url = "{{baseUrl}}/groups"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"subject\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/groups"),
Content = new StringContent("{\n \"subject\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/groups");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"subject\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/groups"
payload := strings.NewReader("{\n \"subject\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/groups HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 19
{
"subject": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/groups")
.setHeader("content-type", "application/json")
.setBody("{\n \"subject\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/groups"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"subject\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"subject\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/groups")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/groups")
.header("content-type", "application/json")
.body("{\n \"subject\": \"\"\n}")
.asString(); const data = JSON.stringify({
subject: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/groups');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/groups',
headers: {'content-type': 'application/json'},
data: {subject: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/groups';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"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}}/groups',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "subject": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"subject\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/groups")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/groups',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({subject: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/groups',
headers: {'content-type': 'application/json'},
body: {subject: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/groups');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
subject: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/groups',
headers: {'content-type': 'application/json'},
data: {subject: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/groups';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"subject":""}'
};
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/json" };
NSDictionary *parameters = @{ @"subject": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups"]
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}}/groups" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"subject\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/groups",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'subject' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/groups', [
'body' => '{
"subject": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/groups');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'subject' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'subject' => ''
]));
$request->setRequestUrl('{{baseUrl}}/groups');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"subject": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"subject": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"subject\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/groups", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/groups"
payload = { "subject": "" }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/groups"
payload <- "{\n \"subject\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/groups")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"subject\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/groups') do |req|
req.body = "{\n \"subject\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/groups";
let payload = json!({"subject": ""});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/groups \
--header 'content-type: application/json' \
--data '{
"subject": ""
}'echo '{
"subject": ""
}' | \
http POST {{baseUrl}}/groups \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "subject": ""\n}' \
--output-document \
- {{baseUrl}}/groupsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["subject": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"groups": [
{
"creation_time": 123456789,
"id": "your-group-id"
}
]
}
DELETE
Delete-Group-Icon
{{baseUrl}}/groups/:GroupId/icon
QUERY PARAMS
GroupId
BODY multipartForm
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:GroupId/icon");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/groups/:GroupId/icon" {:multipart [{:name "File"
:content ""}]})require "http/client"
url = "{{baseUrl}}/groups/:GroupId/icon"
headers = HTTP::Headers{
"content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
response = HTTP::Client.delete url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/groups/:GroupId/icon"),
Content = new MultipartFormDataContent
{
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "File",
}
}
},
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/groups/:GroupId/icon");
var request = new RestRequest("", Method.Delete);
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/groups/:GroupId/icon"
payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
req, _ := http.NewRequest("DELETE", url, payload)
req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/groups/:GroupId/icon HTTP/1.1
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 113
-----011000010111000001101001
Content-Disposition: form-data; name="File"
-----011000010111000001101001--
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/groups/:GroupId/icon")
.setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
.setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/groups/:GroupId/icon"))
.header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
.method("DELETE", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
.url("{{baseUrl}}/groups/:GroupId/icon")
.delete(body)
.addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/groups/:GroupId/icon")
.header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
.body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
.asString(); const data = new FormData();
data.append('File', '');
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/groups/:GroupId/icon');
xhr.send(data);import axios from 'axios';
const form = new FormData();
form.append('File', '');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/groups/:GroupId/icon',
headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
data: '[form]'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/groups/:GroupId/icon';
const form = new FormData();
form.append('File', '');
const options = {method: 'DELETE'};
options.body = form;
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const form = new FormData();
form.append('File', '');
const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/groups/:GroupId/icon',
method: 'DELETE',
headers: {},
processData: false,
contentType: false,
mimeType: 'multipart/form-data',
data: form
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
.url("{{baseUrl}}/groups/:GroupId/icon")
.delete(body)
.addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/groups/:GroupId/icon',
headers: {
'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
}
};
const req = http.request(options, function (res) {
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('-----011000010111000001101001\r\nContent-Disposition: form-data; name="File"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/groups/:GroupId/icon',
headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
formData: {File: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/groups/:GroupId/icon');
req.headers({
'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});
req.multipart([]);
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/groups/:GroupId/icon',
headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="File"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const FormData = require('form-data');
const fetch = require('node-fetch');
const formData = new FormData();
formData.append('File', '');
const url = '{{baseUrl}}/groups/:GroupId/icon';
const options = {method: 'DELETE'};
options.body = formData;
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": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"File", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";
NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
[body appendFormat:@"--%@\r\n", boundary];
if (param[@"fileName"]) {
[body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
[body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
[body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
if (error) {
NSLog(@"%@", error);
}
} else {
[body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
[body appendFormat:@"%@", param[@"value"]];
}
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:GroupId/icon"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[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}}/groups/:GroupId/icon" in
let headers = Header.add (Header.init ()) "content-type" "multipart/form-data; boundary=---011000010111000001101001" in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in
Client.call ~headers ~body `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/groups/:GroupId/icon",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
CURLOPT_HTTPHEADER => [
"content-type: multipart/form-data; boundary=---011000010111000001101001"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/groups/:GroupId/icon', [
'headers' => [
'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/groups/:GroupId/icon');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);
$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="File"
-----011000010111000001101001--
');
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}addForm(null, null);
$request->setRequestUrl('{{baseUrl}}/groups/:GroupId/icon');
$request->setRequestMethod('DELETE');
$request->setBody($body);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:GroupId/icon' -Method DELETE -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="File"
-----011000010111000001101001--
'$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:GroupId/icon' -Method DELETE -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="File"
-----011000010111000001101001--
'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = { 'content-type': "multipart/form-data; boundary=---011000010111000001101001" }
conn.request("DELETE", "/baseUrl/groups/:GroupId/icon", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/groups/:GroupId/icon"
payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {"content-type": "multipart/form-data; boundary=---011000010111000001101001"}
response = requests.delete(url, data=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/groups/:GroupId/icon"
payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
encode <- "multipart"
response <- VERB("DELETE", url, body = payload, content_type("multipart/form-data"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/groups/:GroupId/icon")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)
response = conn.delete('/baseUrl/groups/:GroupId/icon') do |req|
req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/groups/:GroupId/icon";
let form = reqwest::multipart::Form::new()
.text("File", "");
let mut headers = reqwest::header::HeaderMap::new();
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.multipart(form)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/groups/:GroupId/icon \
--header 'content-type: multipart/form-data' \
--form File=echo '-----011000010111000001101001
Content-Disposition: form-data; name="File"
-----011000010111000001101001--
' | \
http DELETE {{baseUrl}}/groups/:GroupId/icon \
content-type:'multipart/form-data; boundary=---011000010111000001101001'wget --quiet \
--method DELETE \
--header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
--body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="File"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
--output-document \
- {{baseUrl}}/groups/:GroupId/iconimport Foundation
let headers = ["content-type": "multipart/form-data; boundary=---011000010111000001101001"]
let parameters = [
[
"name": "File",
"value": ""
]
]
let boundary = "---011000010111000001101001"
var body = ""
var error: NSError? = nil
for param in parameters {
let paramName = param["name"]!
body += "--\(boundary)\r\n"
body += "Content-Disposition:form-data; name=\"\(paramName)\""
if let filename = param["fileName"] {
let contentType = param["content-type"]!
let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
if (error != nil) {
print(error as Any)
}
body += "; filename=\"\(filename)\"\r\n"
body += "Content-Type: \(contentType)\r\n\r\n"
body += fileContent
} else if let paramValue = param["value"] {
body += "\r\n\r\n\(paramValue)"
}
}
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:GroupId/icon")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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-Group-Invite
{{baseUrl}}/groups/:GroupId/invite
QUERY PARAMS
GroupId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:GroupId/invite");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/groups/:GroupId/invite")require "http/client"
url = "{{baseUrl}}/groups/:GroupId/invite"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/groups/:GroupId/invite"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/groups/:GroupId/invite");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/groups/:GroupId/invite"
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/groups/:GroupId/invite HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/groups/:GroupId/invite")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/groups/:GroupId/invite"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/groups/:GroupId/invite")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/groups/:GroupId/invite")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/groups/:GroupId/invite');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/groups/:GroupId/invite'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/groups/:GroupId/invite';
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}}/groups/:GroupId/invite',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/groups/:GroupId/invite")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/groups/:GroupId/invite',
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}}/groups/:GroupId/invite'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/groups/:GroupId/invite');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'DELETE', url: '{{baseUrl}}/groups/:GroupId/invite'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/groups/:GroupId/invite';
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}}/groups/:GroupId/invite"]
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}}/groups/:GroupId/invite" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/groups/:GroupId/invite",
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}}/groups/:GroupId/invite');
echo $response->getBody();setUrl('{{baseUrl}}/groups/:GroupId/invite');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/groups/:GroupId/invite');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:GroupId/invite' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:GroupId/invite' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/groups/:GroupId/invite")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/groups/:GroupId/invite"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/groups/:GroupId/invite"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/groups/:GroupId/invite")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/groups/:GroupId/invite') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/groups/:GroupId/invite";
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}}/groups/:GroupId/invitehttp DELETE {{baseUrl}}/groups/:GroupId/invitewget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/groups/:GroupId/inviteimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:GroupId/invite")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Demote-Group-Admin
{{baseUrl}}/groups/:GroupId/admins
QUERY PARAMS
GroupId
BODY json
{
"wa_ids": []
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:GroupId/admins");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"wa_ids\": [\n \"\"\n ]\n}");
CURLcode ret = curl_easy_perform(hnd); (require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/groups/:GroupId/admins" {:content-type :json
:form-params {:wa_ids [""]}}) require "http/client"
url = "{{baseUrl}}/groups/:GroupId/admins"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"wa_ids\": [\n \"\"\n ]\n}"
response = HTTP::Client.delete url, headers: headers, body: reqBody
puts response.body using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/groups/:GroupId/admins"),
Content = new StringContent("{\n \"wa_ids\": [\n \"\"\n ]\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
} var client = new RestClient("{{baseUrl}}/groups/:GroupId/admins");
var request = new RestRequest("", Method.Delete);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"wa_ids\": [\n \"\"\n ]\n}", ParameterType.RequestBody);
var response = client.Execute(request); package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/groups/:GroupId/admins"
payload := strings.NewReader("{\n \"wa_ids\": [\n \"\"\n ]\n}")
req, _ := http.NewRequest("DELETE", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
} DELETE /baseUrl/groups/:GroupId/admins HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 64
{
"wa_ids": [
""
]
} AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/groups/:GroupId/admins")
.setHeader("content-type", "application/json")
.setBody("{\n \"wa_ids\": [\n \"\"\n ]\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close(); HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/groups/:GroupId/admins"))
.header("content-type", "application/json")
.method("DELETE", HttpRequest.BodyPublishers.ofString("{\n \"wa_ids\": [\n \"\"\n ]\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"wa_ids\": [\n \"\"\n ]\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/groups/:GroupId/admins")
.delete(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute(); HttpResponse response = Unirest.delete("{{baseUrl}}/groups/:GroupId/admins")
.header("content-type", "application/json")
.body("{\n \"wa_ids\": [\n \"\"\n ]\n}")
.asString(); const data = JSON.stringify({
wa_ids: [
''
]
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/groups/:GroupId/admins');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data); import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/groups/:GroupId/admins',
headers: {'content-type': 'application/json'},
data: {wa_ids: ['']}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
} const url = '{{baseUrl}}/groups/:GroupId/admins';
const options = {
method: 'DELETE',
headers: {'content-type': 'application/json'},
body: '{"wa_ids":[""]}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
} const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/groups/:GroupId/admins',
method: 'DELETE',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "wa_ids": [\n ""\n ]\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
}); val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"wa_ids\": [\n \"\"\n ]\n}")
val request = Request.Builder()
.url("{{baseUrl}}/groups/:GroupId/admins")
.delete(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute() const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/groups/:GroupId/admins',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({wa_ids: ['']}));
req.end(); const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/groups/:GroupId/admins',
headers: {'content-type': 'application/json'},
body: {wa_ids: ['']},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
}); const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/groups/:GroupId/admins');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
wa_ids: [
''
]
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
}); const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/groups/:GroupId/admins',
headers: {'content-type': 'application/json'},
data: {wa_ids: ['']}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
} const fetch = require('node-fetch');
const url = '{{baseUrl}}/groups/:GroupId/admins';
const options = {
method: 'DELETE',
headers: {'content-type': 'application/json'},
body: '{"wa_ids":[""]}'
};
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/json" };
NSDictionary *parameters = @{ @"wa_ids": @[ @"" ] };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:GroupId/admins"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[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}}/groups/:GroupId/admins" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"wa_ids\": [\n \"\"\n ]\n}" in
Client.call ~headers ~body `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/groups/:GroupId/admins",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_POSTFIELDS => json_encode([
'wa_ids' => [
''
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
} request('DELETE', '{{baseUrl}}/groups/:GroupId/admins', [
'body' => '{
"wa_ids": [
""
]
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody(); setUrl('{{baseUrl}}/groups/:GroupId/admins');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'wa_ids' => [
''
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
} append(json_encode([
'wa_ids' => [
''
]
]));
$request->setRequestUrl('{{baseUrl}}/groups/:GroupId/admins');
$request->setRequestMethod('DELETE');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody(); $headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:GroupId/admins' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '{
"wa_ids": [
""
]
}' $headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:GroupId/admins' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '{
"wa_ids": [
""
]
}' import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"wa_ids\": [\n \"\"\n ]\n}"
headers = { 'content-type': "application/json" }
conn.request("DELETE", "/baseUrl/groups/:GroupId/admins", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8")) import requests
url = "{{baseUrl}}/groups/:GroupId/admins"
payload = { "wa_ids": [""] }
headers = {"content-type": "application/json"}
response = requests.delete(url, json=payload, headers=headers)
print(response.json()) library(httr)
url <- "{{baseUrl}}/groups/:GroupId/admins"
payload <- "{\n \"wa_ids\": [\n \"\"\n ]\n}"
encode <- "json"
response <- VERB("DELETE", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text") require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/groups/:GroupId/admins")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"wa_ids\": [\n \"\"\n ]\n}"
response = http.request(request)
puts response.read_body require 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.delete('/baseUrl/groups/:GroupId/admins') do |req|
req.body = "{\n \"wa_ids\": [\n \"\"\n ]\n}"
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}}/groups/:GroupId/admins";
let payload = json!({"wa_ids": ("")});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/groups/:GroupId/admins \
--header 'content-type: application/json' \
--data '{
"wa_ids": [
""
]
}' echo '{
"wa_ids": [
""
]
}' | \
http DELETE {{baseUrl}}/groups/:GroupId/admins \
content-type:application/json wget --quiet \
--method DELETE \
--header 'content-type: application/json' \
--body-data '{\n "wa_ids": [\n ""\n ]\n}' \
--output-document \
- {{baseUrl}}/groups/:GroupId/admins import Foundation
let headers = ["content-type": "application/json"]
let parameters = ["wa_ids": [""]] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:GroupId/admins")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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
Get-All-Groups
{{baseUrl}}/groups
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/groups")require "http/client"
url = "{{baseUrl}}/groups"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/groups"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/groups");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/groups"
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/groups HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/groups")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/groups"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/groups")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/groups")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/groups');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/groups'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/groups';
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}}/groups',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/groups")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/groups',
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}}/groups'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/groups');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/groups'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/groups';
const options = {method: 'GET'};
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}}/groups"]
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}}/groups" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/groups",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/groups');
echo $response->getBody();setUrl('{{baseUrl}}/groups');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/groups');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/groups' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/groups")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/groups"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/groups"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/groups")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/groups') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/groups";
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}}/groupshttp GET {{baseUrl}}/groupswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/groupsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"groups": [
{
"creation_time": 123456789,
"id": "your-group-id"
}
]
}
GET
Get-Group-Icon-Binary
{{baseUrl}}/groups/:GroupId/icon
QUERY PARAMS
GroupId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:GroupId/icon");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/groups/:GroupId/icon")require "http/client"
url = "{{baseUrl}}/groups/:GroupId/icon"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/groups/:GroupId/icon"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/groups/:GroupId/icon");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/groups/:GroupId/icon"
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/groups/:GroupId/icon HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/groups/:GroupId/icon")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/groups/:GroupId/icon"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/groups/:GroupId/icon")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/groups/:GroupId/icon")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/groups/:GroupId/icon');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/groups/:GroupId/icon'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/groups/:GroupId/icon';
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}}/groups/:GroupId/icon',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/groups/:GroupId/icon")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/groups/:GroupId/icon',
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}}/groups/:GroupId/icon'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/groups/:GroupId/icon');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/groups/:GroupId/icon'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/groups/:GroupId/icon';
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}}/groups/:GroupId/icon"]
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}}/groups/:GroupId/icon" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/groups/:GroupId/icon",
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}}/groups/:GroupId/icon');
echo $response->getBody();setUrl('{{baseUrl}}/groups/:GroupId/icon');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/groups/:GroupId/icon');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:GroupId/icon' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:GroupId/icon' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/groups/:GroupId/icon")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/groups/:GroupId/icon"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/groups/:GroupId/icon"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/groups/:GroupId/icon")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/groups/:GroupId/icon') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/groups/:GroupId/icon";
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}}/groups/:GroupId/iconhttp GET {{baseUrl}}/groups/:GroupId/iconwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/groups/:GroupId/iconimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:GroupId/icon")! 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
Get-Group-Info
{{baseUrl}}/groups/:GroupId
QUERY PARAMS
GroupId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:GroupId");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/groups/:GroupId")require "http/client"
url = "{{baseUrl}}/groups/:GroupId"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/groups/:GroupId"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/groups/:GroupId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/groups/:GroupId"
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/groups/:GroupId HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/groups/:GroupId")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/groups/:GroupId"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/groups/:GroupId")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/groups/:GroupId")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/groups/:GroupId');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/groups/:GroupId'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/groups/:GroupId';
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}}/groups/:GroupId',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/groups/:GroupId")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/groups/:GroupId',
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}}/groups/:GroupId'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/groups/:GroupId');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/groups/:GroupId'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/groups/:GroupId';
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}}/groups/:GroupId"]
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}}/groups/:GroupId" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/groups/:GroupId",
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}}/groups/:GroupId');
echo $response->getBody();setUrl('{{baseUrl}}/groups/:GroupId');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/groups/:GroupId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:GroupId' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:GroupId' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/groups/:GroupId")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/groups/:GroupId"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/groups/:GroupId"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/groups/:GroupId")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/groups/:GroupId') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/groups/:GroupId";
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}}/groups/:GroupIdhttp GET {{baseUrl}}/groups/:GroupIdwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/groups/:GroupIdimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:GroupId")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"groups": [
{
"admins": [
"whatsapp-id-1",
"whatsapp-id-2"
],
"creation_time": 123456789,
"creator": "whatsapp-id-1",
"participants": [
"whatsapp-id-3",
"whatsapp-id-4",
"whatsapp-id-5"
],
"subject": "your-group-subject"
}
]
}
GET
Get-Group-Invite
{{baseUrl}}/groups/:GroupId/invite
QUERY PARAMS
GroupId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:GroupId/invite");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/groups/:GroupId/invite")require "http/client"
url = "{{baseUrl}}/groups/:GroupId/invite"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/groups/:GroupId/invite"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/groups/:GroupId/invite");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/groups/:GroupId/invite"
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/groups/:GroupId/invite HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/groups/:GroupId/invite")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/groups/:GroupId/invite"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/groups/:GroupId/invite")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/groups/:GroupId/invite")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/groups/:GroupId/invite');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/groups/:GroupId/invite'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/groups/:GroupId/invite';
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}}/groups/:GroupId/invite',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/groups/:GroupId/invite")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/groups/:GroupId/invite',
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}}/groups/:GroupId/invite'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/groups/:GroupId/invite');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/groups/:GroupId/invite'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/groups/:GroupId/invite';
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}}/groups/:GroupId/invite"]
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}}/groups/:GroupId/invite" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/groups/:GroupId/invite",
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}}/groups/:GroupId/invite');
echo $response->getBody();setUrl('{{baseUrl}}/groups/:GroupId/invite');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/groups/:GroupId/invite');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:GroupId/invite' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:GroupId/invite' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/groups/:GroupId/invite")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/groups/:GroupId/invite"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/groups/:GroupId/invite"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/groups/:GroupId/invite")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/groups/:GroupId/invite') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/groups/:GroupId/invite";
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}}/groups/:GroupId/invitehttp GET {{baseUrl}}/groups/:GroupId/invitewget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/groups/:GroupId/inviteimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:GroupId/invite")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"groups": [
{
"link": "group-invite-link"
}
]
}
POST
Leave-Group
{{baseUrl}}/groups/:GroupId/leave
QUERY PARAMS
GroupId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:GroupId/leave");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/groups/:GroupId/leave")require "http/client"
url = "{{baseUrl}}/groups/:GroupId/leave"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/groups/:GroupId/leave"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/groups/:GroupId/leave");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/groups/:GroupId/leave"
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/groups/:GroupId/leave HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/groups/:GroupId/leave")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/groups/:GroupId/leave"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/groups/:GroupId/leave")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/groups/:GroupId/leave")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/groups/:GroupId/leave');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/groups/:GroupId/leave'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/groups/:GroupId/leave';
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}}/groups/:GroupId/leave',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/groups/:GroupId/leave")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/groups/:GroupId/leave',
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}}/groups/:GroupId/leave'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/groups/:GroupId/leave');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'POST', url: '{{baseUrl}}/groups/:GroupId/leave'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/groups/:GroupId/leave';
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}}/groups/:GroupId/leave"]
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}}/groups/:GroupId/leave" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/groups/:GroupId/leave",
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}}/groups/:GroupId/leave');
echo $response->getBody();setUrl('{{baseUrl}}/groups/:GroupId/leave');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/groups/:GroupId/leave');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:GroupId/leave' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:GroupId/leave' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/groups/:GroupId/leave")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/groups/:GroupId/leave"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/groups/:GroupId/leave"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/groups/:GroupId/leave")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/groups/:GroupId/leave') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/groups/:GroupId/leave";
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}}/groups/:GroupId/leavehttp POST {{baseUrl}}/groups/:GroupId/leavewget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/groups/:GroupId/leaveimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:GroupId/leave")! 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()
PATCH
Promote-To-Group-Admin
{{baseUrl}}/groups/:GroupId/admins
QUERY PARAMS
GroupId
BODY json
{
"wa_ids": []
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:GroupId/admins");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"wa_ids\": [\n \"\"\n ]\n}");
CURLcode ret = curl_easy_perform(hnd); (require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/groups/:GroupId/admins" {:content-type :json
:form-params {:wa_ids [""]}}) require "http/client"
url = "{{baseUrl}}/groups/:GroupId/admins"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"wa_ids\": [\n \"\"\n ]\n}"
response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/groups/:GroupId/admins"),
Content = new StringContent("{\n \"wa_ids\": [\n \"\"\n ]\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
} var client = new RestClient("{{baseUrl}}/groups/:GroupId/admins");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"wa_ids\": [\n \"\"\n ]\n}", ParameterType.RequestBody);
var response = client.Execute(request); package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/groups/:GroupId/admins"
payload := strings.NewReader("{\n \"wa_ids\": [\n \"\"\n ]\n}")
req, _ := http.NewRequest("PATCH", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
} PATCH /baseUrl/groups/:GroupId/admins HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 64
{
"wa_ids": [
""
]
} AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/groups/:GroupId/admins")
.setHeader("content-type", "application/json")
.setBody("{\n \"wa_ids\": [\n \"\"\n ]\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close(); HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/groups/:GroupId/admins"))
.header("content-type", "application/json")
.method("PATCH", HttpRequest.BodyPublishers.ofString("{\n \"wa_ids\": [\n \"\"\n ]\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"wa_ids\": [\n \"\"\n ]\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/groups/:GroupId/admins")
.patch(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute(); HttpResponse response = Unirest.patch("{{baseUrl}}/groups/:GroupId/admins")
.header("content-type", "application/json")
.body("{\n \"wa_ids\": [\n \"\"\n ]\n}")
.asString(); const data = JSON.stringify({
wa_ids: [
''
]
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/groups/:GroupId/admins');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data); import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/groups/:GroupId/admins',
headers: {'content-type': 'application/json'},
data: {wa_ids: ['']}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
} const url = '{{baseUrl}}/groups/:GroupId/admins';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"wa_ids":[""]}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
} const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/groups/:GroupId/admins',
method: 'PATCH',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "wa_ids": [\n ""\n ]\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
}); val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"wa_ids\": [\n \"\"\n ]\n}")
val request = Request.Builder()
.url("{{baseUrl}}/groups/:GroupId/admins")
.patch(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute() const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/groups/:GroupId/admins',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({wa_ids: ['']}));
req.end(); const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/groups/:GroupId/admins',
headers: {'content-type': 'application/json'},
body: {wa_ids: ['']},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
}); const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/groups/:GroupId/admins');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
wa_ids: [
''
]
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
}); const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/groups/:GroupId/admins',
headers: {'content-type': 'application/json'},
data: {wa_ids: ['']}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
} const fetch = require('node-fetch');
const url = '{{baseUrl}}/groups/:GroupId/admins';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"wa_ids":[""]}'
};
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/json" };
NSDictionary *parameters = @{ @"wa_ids": @[ @"" ] };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:GroupId/admins"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/groups/:GroupId/admins" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"wa_ids\": [\n \"\"\n ]\n}" in
Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/groups/:GroupId/admins",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
CURLOPT_POSTFIELDS => json_encode([
'wa_ids' => [
''
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
} request('PATCH', '{{baseUrl}}/groups/:GroupId/admins', [
'body' => '{
"wa_ids": [
""
]
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody(); setUrl('{{baseUrl}}/groups/:GroupId/admins');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'wa_ids' => [
''
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
} append(json_encode([
'wa_ids' => [
''
]
]));
$request->setRequestUrl('{{baseUrl}}/groups/:GroupId/admins');
$request->setRequestMethod('PATCH');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody(); $headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:GroupId/admins' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"wa_ids": [
""
]
}' $headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:GroupId/admins' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"wa_ids": [
""
]
}' import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"wa_ids\": [\n \"\"\n ]\n}"
headers = { 'content-type': "application/json" }
conn.request("PATCH", "/baseUrl/groups/:GroupId/admins", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8")) import requests
url = "{{baseUrl}}/groups/:GroupId/admins"
payload = { "wa_ids": [""] }
headers = {"content-type": "application/json"}
response = requests.patch(url, json=payload, headers=headers)
print(response.json()) library(httr)
url <- "{{baseUrl}}/groups/:GroupId/admins"
payload <- "{\n \"wa_ids\": [\n \"\"\n ]\n}"
encode <- "json"
response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text") require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/groups/:GroupId/admins")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"wa_ids\": [\n \"\"\n ]\n}"
response = http.request(request)
puts response.read_body require 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.patch('/baseUrl/groups/:GroupId/admins') do |req|
req.body = "{\n \"wa_ids\": [\n \"\"\n ]\n}"
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}}/groups/:GroupId/admins";
let payload = json!({"wa_ids": ("")});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/groups/:GroupId/admins \
--header 'content-type: application/json' \
--data '{
"wa_ids": [
""
]
}' echo '{
"wa_ids": [
""
]
}' | \
http PATCH {{baseUrl}}/groups/:GroupId/admins \
content-type:application/json wget --quiet \
--method PATCH \
--header 'content-type: application/json' \
--body-data '{\n "wa_ids": [\n ""\n ]\n}' \
--output-document \
- {{baseUrl}}/groups/:GroupId/admins import Foundation
let headers = ["content-type": "application/json"]
let parameters = ["wa_ids": [""]] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:GroupId/admins")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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
Remove-Group-Participant
{{baseUrl}}/groups/:GroupId/participants
QUERY PARAMS
GroupId
BODY json
{
"wa_ids": []
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:GroupId/participants");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"wa_ids\": [\n \"{{Recipient-WA-ID}}\"\n ]\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/groups/:GroupId/participants" {:content-type :json
:form-params {:wa_ids ["{{Recipient-WA-ID}}"]}})require "http/client"
url = "{{baseUrl}}/groups/:GroupId/participants"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"wa_ids\": [\n \"{{Recipient-WA-ID}}\"\n ]\n}"
response = HTTP::Client.delete url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/groups/:GroupId/participants"),
Content = new StringContent("{\n \"wa_ids\": [\n \"{{Recipient-WA-ID}}\"\n ]\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/groups/:GroupId/participants");
var request = new RestRequest("", Method.Delete);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"wa_ids\": [\n \"{{Recipient-WA-ID}}\"\n ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/groups/:GroupId/participants"
payload := strings.NewReader("{\n \"wa_ids\": [\n \"{{Recipient-WA-ID}}\"\n ]\n}")
req, _ := http.NewRequest("DELETE", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/groups/:GroupId/participants HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 47
{
"wa_ids": [
"{{Recipient-WA-ID}}"
]
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/groups/:GroupId/participants")
.setHeader("content-type", "application/json")
.setBody("{\n \"wa_ids\": [\n \"{{Recipient-WA-ID}}\"\n ]\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/groups/:GroupId/participants"))
.header("content-type", "application/json")
.method("DELETE", HttpRequest.BodyPublishers.ofString("{\n \"wa_ids\": [\n \"{{Recipient-WA-ID}}\"\n ]\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"wa_ids\": [\n \"{{Recipient-WA-ID}}\"\n ]\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/groups/:GroupId/participants")
.delete(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/groups/:GroupId/participants")
.header("content-type", "application/json")
.body("{\n \"wa_ids\": [\n \"{{Recipient-WA-ID}}\"\n ]\n}")
.asString(); const data = JSON.stringify({
wa_ids: [
'{{Recipient-WA-ID}}'
]
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/groups/:GroupId/participants');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/groups/:GroupId/participants',
headers: {'content-type': 'application/json'},
data: {wa_ids: ['{{Recipient-WA-ID}}']}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/groups/:GroupId/participants';
const options = {
method: 'DELETE',
headers: {'content-type': 'application/json'},
body: '{"wa_ids":["{{Recipient-WA-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}}/groups/:GroupId/participants',
method: 'DELETE',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "wa_ids": [\n "{{Recipient-WA-ID}}"\n ]\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"wa_ids\": [\n \"{{Recipient-WA-ID}}\"\n ]\n}")
val request = Request.Builder()
.url("{{baseUrl}}/groups/:GroupId/participants")
.delete(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/groups/:GroupId/participants',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({wa_ids: ['{{Recipient-WA-ID}}']}));
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/groups/:GroupId/participants',
headers: {'content-type': 'application/json'},
body: {wa_ids: ['{{Recipient-WA-ID}}']},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/groups/:GroupId/participants');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
wa_ids: [
'{{Recipient-WA-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}}/groups/:GroupId/participants',
headers: {'content-type': 'application/json'},
data: {wa_ids: ['{{Recipient-WA-ID}}']}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/groups/:GroupId/participants';
const options = {
method: 'DELETE',
headers: {'content-type': 'application/json'},
body: '{"wa_ids":["{{Recipient-WA-ID}}"]}'
};
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/json" };
NSDictionary *parameters = @{ @"wa_ids": @[ @"{{Recipient-WA-ID}}" ] };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:GroupId/participants"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[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}}/groups/:GroupId/participants" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"wa_ids\": [\n \"{{Recipient-WA-ID}}\"\n ]\n}" in
Client.call ~headers ~body `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/groups/:GroupId/participants",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_POSTFIELDS => json_encode([
'wa_ids' => [
'{{Recipient-WA-ID}}'
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/groups/:GroupId/participants', [
'body' => '{
"wa_ids": [
"{{Recipient-WA-ID}}"
]
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/groups/:GroupId/participants');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'wa_ids' => [
'{{Recipient-WA-ID}}'
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'wa_ids' => [
'{{Recipient-WA-ID}}'
]
]));
$request->setRequestUrl('{{baseUrl}}/groups/:GroupId/participants');
$request->setRequestMethod('DELETE');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:GroupId/participants' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '{
"wa_ids": [
"{{Recipient-WA-ID}}"
]
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:GroupId/participants' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '{
"wa_ids": [
"{{Recipient-WA-ID}}"
]
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"wa_ids\": [\n \"{{Recipient-WA-ID}}\"\n ]\n}"
headers = { 'content-type': "application/json" }
conn.request("DELETE", "/baseUrl/groups/:GroupId/participants", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/groups/:GroupId/participants"
payload = { "wa_ids": ["{{Recipient-WA-ID}}"] }
headers = {"content-type": "application/json"}
response = requests.delete(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/groups/:GroupId/participants"
payload <- "{\n \"wa_ids\": [\n \"{{Recipient-WA-ID}}\"\n ]\n}"
encode <- "json"
response <- VERB("DELETE", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/groups/:GroupId/participants")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"wa_ids\": [\n \"{{Recipient-WA-ID}}\"\n ]\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.delete('/baseUrl/groups/:GroupId/participants') do |req|
req.body = "{\n \"wa_ids\": [\n \"{{Recipient-WA-ID}}\"\n ]\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/groups/:GroupId/participants";
let payload = json!({"wa_ids": ("{{Recipient-WA-ID}}")});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/groups/:GroupId/participants \
--header 'content-type: application/json' \
--data '{
"wa_ids": [
"{{Recipient-WA-ID}}"
]
}'echo '{
"wa_ids": [
"{{Recipient-WA-ID}}"
]
}' | \
http DELETE {{baseUrl}}/groups/:GroupId/participants \
content-type:application/jsonwget --quiet \
--method DELETE \
--header 'content-type: application/json' \
--body-data '{\n "wa_ids": [\n "{{Recipient-WA-ID}}"\n ]\n}' \
--output-document \
- {{baseUrl}}/groups/:GroupId/participantsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["wa_ids": ["{{Recipient-WA-ID}}"]] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:GroupId/participants")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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
Set-Group-Icon
{{baseUrl}}/groups/:GroupId/icon
QUERY PARAMS
GroupId
BODY multipartForm
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:GroupId/icon");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/groups/:GroupId/icon" {:multipart [{:name "File"
:content ""}]})require "http/client"
url = "{{baseUrl}}/groups/:GroupId/icon"
headers = HTTP::Headers{
"content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/groups/:GroupId/icon"),
Content = new MultipartFormDataContent
{
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "File",
}
}
},
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/groups/:GroupId/icon");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/groups/:GroupId/icon"
payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/groups/:GroupId/icon HTTP/1.1
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 113
-----011000010111000001101001
Content-Disposition: form-data; name="File"
-----011000010111000001101001--
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/groups/:GroupId/icon")
.setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
.setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/groups/:GroupId/icon"))
.header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
.method("POST", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
.url("{{baseUrl}}/groups/:GroupId/icon")
.post(body)
.addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/groups/:GroupId/icon")
.header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
.body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
.asString(); const data = new FormData();
data.append('File', '');
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/groups/:GroupId/icon');
xhr.send(data);import axios from 'axios';
const form = new FormData();
form.append('File', '');
const options = {
method: 'POST',
url: '{{baseUrl}}/groups/:GroupId/icon',
headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
data: '[form]'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/groups/:GroupId/icon';
const form = new FormData();
form.append('File', '');
const options = {method: 'POST'};
options.body = form;
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const form = new FormData();
form.append('File', '');
const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/groups/:GroupId/icon',
method: 'POST',
headers: {},
processData: false,
contentType: false,
mimeType: 'multipart/form-data',
data: form
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
.url("{{baseUrl}}/groups/:GroupId/icon")
.post(body)
.addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/groups/:GroupId/icon',
headers: {
'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
}
};
const req = http.request(options, function (res) {
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('-----011000010111000001101001\r\nContent-Disposition: form-data; name="File"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/groups/:GroupId/icon',
headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
formData: {File: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/groups/:GroupId/icon');
req.headers({
'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});
req.multipart([]);
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/groups/:GroupId/icon',
headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="File"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const FormData = require('form-data');
const fetch = require('node-fetch');
const formData = new FormData();
formData.append('File', '');
const url = '{{baseUrl}}/groups/:GroupId/icon';
const options = {method: 'POST'};
options.body = formData;
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": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"File", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";
NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
[body appendFormat:@"--%@\r\n", boundary];
if (param[@"fileName"]) {
[body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
[body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
[body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
if (error) {
NSLog(@"%@", error);
}
} else {
[body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
[body appendFormat:@"%@", param[@"value"]];
}
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:GroupId/icon"]
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}}/groups/:GroupId/icon" in
let headers = Header.add (Header.init ()) "content-type" "multipart/form-data; boundary=---011000010111000001101001" in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/groups/:GroupId/icon",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
CURLOPT_HTTPHEADER => [
"content-type: multipart/form-data; boundary=---011000010111000001101001"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/groups/:GroupId/icon', [
'headers' => [
'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/groups/:GroupId/icon');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);
$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="File"
-----011000010111000001101001--
');
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}addForm(null, null);
$request->setRequestUrl('{{baseUrl}}/groups/:GroupId/icon');
$request->setRequestMethod('POST');
$request->setBody($body);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:GroupId/icon' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="File"
-----011000010111000001101001--
'$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:GroupId/icon' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="File"
-----011000010111000001101001--
'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = { 'content-type': "multipart/form-data; boundary=---011000010111000001101001" }
conn.request("POST", "/baseUrl/groups/:GroupId/icon", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/groups/:GroupId/icon"
payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {"content-type": "multipart/form-data; boundary=---011000010111000001101001"}
response = requests.post(url, data=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/groups/:GroupId/icon"
payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
encode <- "multipart"
response <- VERB("POST", url, body = payload, content_type("multipart/form-data"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/groups/:GroupId/icon")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)
response = conn.post('/baseUrl/groups/:GroupId/icon') do |req|
req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/groups/:GroupId/icon";
let form = reqwest::multipart::Form::new()
.text("File", "");
let mut headers = reqwest::header::HeaderMap::new();
let client = reqwest::Client::new();
let response = client.post(url)
.multipart(form)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/groups/:GroupId/icon \
--header 'content-type: multipart/form-data' \
--form File=echo '-----011000010111000001101001
Content-Disposition: form-data; name="File"
-----011000010111000001101001--
' | \
http POST {{baseUrl}}/groups/:GroupId/icon \
content-type:'multipart/form-data; boundary=---011000010111000001101001'wget --quiet \
--method POST \
--header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
--body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="File"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
--output-document \
- {{baseUrl}}/groups/:GroupId/iconimport Foundation
let headers = ["content-type": "multipart/form-data; boundary=---011000010111000001101001"]
let parameters = [
[
"name": "File",
"value": ""
]
]
let boundary = "---011000010111000001101001"
var body = ""
var error: NSError? = nil
for param in parameters {
let paramName = param["name"]!
body += "--\(boundary)\r\n"
body += "Content-Disposition:form-data; name=\"\(paramName)\""
if let filename = param["fileName"] {
let contentType = param["content-type"]!
let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
if (error != nil) {
print(error as Any)
}
body += "; filename=\"\(filename)\"\r\n"
body += "Content-Type: \(contentType)\r\n\r\n"
body += fileContent
} else if let paramValue = param["value"] {
body += "\r\n\r\n\(paramValue)"
}
}
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:GroupId/icon")! 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()
PUT
Update-Group-Info
{{baseUrl}}/groups/:GroupId
QUERY PARAMS
GroupId
BODY json
{
"subject": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:GroupId");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"subject\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd); (require '[clj-http.client :as client])
(client/put "{{baseUrl}}/groups/:GroupId" {:content-type :json
:form-params {:subject ""}}) require "http/client"
url = "{{baseUrl}}/groups/:GroupId"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"subject\": \"\"\n}"
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}}/groups/:GroupId"),
Content = new StringContent("{\n \"subject\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
} var client = new RestClient("{{baseUrl}}/groups/:GroupId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"subject\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request); package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/groups/:GroupId"
payload := strings.NewReader("{\n \"subject\": \"\"\n}")
req, _ := http.NewRequest("PUT", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
} PUT /baseUrl/groups/:GroupId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 38
{
"subject": ""
} AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/groups/:GroupId")
.setHeader("content-type", "application/json")
.setBody("{\n \"subject\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close(); HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/groups/:GroupId"))
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("{\n \"subject\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"subject\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/groups/:GroupId")
.put(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute(); HttpResponse response = Unirest.put("{{baseUrl}}/groups/:GroupId")
.header("content-type", "application/json")
.body("{\n \"subject\": \"\"\n}")
.asString(); const data = JSON.stringify({
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}}/groups/:GroupId');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data); import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/groups/:GroupId',
headers: {'content-type': 'application/json'},
data: {subject: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
} const url = '{{baseUrl}}/groups/:GroupId';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"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}}/groups/:GroupId',
method: 'PUT',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "subject": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
}); val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"subject\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/groups/:GroupId")
.put(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute() const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/groups/:GroupId',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({subject: ''}));
req.end(); const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/groups/:GroupId',
headers: {'content-type': 'application/json'},
body: {subject: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
}); const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/groups/:GroupId');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
subject: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
}); const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/groups/:GroupId',
headers: {'content-type': 'application/json'},
data: {subject: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
} const fetch = require('node-fetch');
const url = '{{baseUrl}}/groups/:GroupId';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"subject":""}'
};
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/json" };
NSDictionary *parameters = @{ @"subject": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:GroupId"]
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}}/groups/:GroupId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"subject\": \"\"\n}" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/groups/:GroupId",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
'subject' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
} request('PUT', '{{baseUrl}}/groups/:GroupId', [
'body' => '{
"subject": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody(); setUrl('{{baseUrl}}/groups/:GroupId');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'subject' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
} append(json_encode([
'subject' => ''
]));
$request->setRequestUrl('{{baseUrl}}/groups/:GroupId');
$request->setRequestMethod('PUT');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody(); $headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:GroupId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"subject": ""
}' $headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:GroupId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"subject": ""
}' import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"subject\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PUT", "/baseUrl/groups/:GroupId", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8")) import requests
url = "{{baseUrl}}/groups/:GroupId"
payload = { "subject": "" }
headers = {"content-type": "application/json"}
response = requests.put(url, json=payload, headers=headers)
print(response.json()) library(httr)
url <- "{{baseUrl}}/groups/:GroupId"
payload <- "{\n \"subject\": \"\"\n}"
encode <- "json"
response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text") require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/groups/:GroupId")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"subject\": \"\"\n}"
response = http.request(request)
puts response.read_body require 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.put('/baseUrl/groups/:GroupId') do |req|
req.body = "{\n \"subject\": \"\"\n}"
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}}/groups/:GroupId";
let payload = json!({"subject": ""});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/groups/:GroupId \
--header 'content-type: application/json' \
--data '{
"subject": ""
}' echo '{
"subject": ""
}' | \
http PUT {{baseUrl}}/groups/:GroupId \
content-type:application/json wget --quiet \
--method PUT \
--header 'content-type: application/json' \
--body-data '{\n "subject": ""\n}' \
--output-document \
- {{baseUrl}}/groups/:GroupId import Foundation
let headers = ["content-type": "application/json"]
let parameters = ["subject": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:GroupId")! 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
Check-Health
{{baseUrl}}/health
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/health");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/health")require "http/client"
url = "{{baseUrl}}/health"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/health"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/health");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/health"
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/health HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/health")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/health"))
.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}}/health")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/health")
.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}}/health');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/health'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/health';
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}}/health',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/health")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/health',
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}}/health'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/health');
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}}/health'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/health';
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}}/health"]
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}}/health" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/health",
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}}/health');
echo $response->getBody();setUrl('{{baseUrl}}/health');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/health');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/health' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/health' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/health")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/health"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/health"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/health")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/health') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/health";
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}}/healthhttp GET {{baseUrl}}/healthwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/healthimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/health")! 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
Get-App-Stats
{{baseUrl}}/stats/app
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stats/app");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stats/app")require "http/client"
url = "{{baseUrl}}/stats/app"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stats/app"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stats/app");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stats/app"
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/stats/app HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stats/app")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stats/app"))
.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}}/stats/app")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stats/app")
.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}}/stats/app');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/stats/app'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stats/app';
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}}/stats/app',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stats/app")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stats/app',
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}}/stats/app'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stats/app');
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}}/stats/app'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stats/app';
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}}/stats/app"]
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}}/stats/app" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stats/app",
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}}/stats/app');
echo $response->getBody();setUrl('{{baseUrl}}/stats/app');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stats/app');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stats/app' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/stats/app' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/stats/app")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stats/app"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stats/app"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stats/app")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stats/app') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stats/app";
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}}/stats/apphttp GET {{baseUrl}}/stats/appwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/stats/appimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stats/app")! 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
Get-DB-Stats
{{baseUrl}}/stats/db
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stats/db");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stats/db")require "http/client"
url = "{{baseUrl}}/stats/db"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stats/db"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stats/db");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stats/db"
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/stats/db HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stats/db")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stats/db"))
.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}}/stats/db")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stats/db")
.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}}/stats/db');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/stats/db'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stats/db';
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}}/stats/db',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stats/db")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stats/db',
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}}/stats/db'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stats/db');
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}}/stats/db'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stats/db';
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}}/stats/db"]
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}}/stats/db" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stats/db",
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}}/stats/db');
echo $response->getBody();setUrl('{{baseUrl}}/stats/db');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stats/db');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stats/db' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/stats/db' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/stats/db")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stats/db"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stats/db"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stats/db")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stats/db') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stats/db";
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}}/stats/dbhttp GET {{baseUrl}}/stats/dbwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/stats/dbimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stats/db")! 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
Get-Metrics (since v2.21.3)
{{baseUrl}}/metrics
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/metrics");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/metrics")require "http/client"
url = "{{baseUrl}}/metrics"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/metrics"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/metrics");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/metrics"
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/metrics HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/metrics")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/metrics"))
.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}}/metrics")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/metrics")
.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}}/metrics');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/metrics'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/metrics';
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}}/metrics',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/metrics")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/metrics',
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}}/metrics'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/metrics');
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}}/metrics'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/metrics';
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}}/metrics"]
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}}/metrics" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/metrics",
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}}/metrics');
echo $response->getBody();setUrl('{{baseUrl}}/metrics');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/metrics');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/metrics' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/metrics' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/metrics")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/metrics"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/metrics"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/metrics")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/metrics') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/metrics";
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}}/metricshttp GET {{baseUrl}}/metricswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/metricsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/metrics")! 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
Get-Support-Info
{{baseUrl}}/support
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/support");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/support")require "http/client"
url = "{{baseUrl}}/support"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/support"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/support");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/support"
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/support HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/support")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/support"))
.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}}/support")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/support")
.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}}/support');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/support'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/support';
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}}/support',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/support")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/support',
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}}/support'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/support');
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}}/support'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/support';
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}}/support"]
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}}/support" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/support",
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}}/support');
echo $response->getBody();setUrl('{{baseUrl}}/support');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/support');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/support' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/support' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/support")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/support"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/support"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/support")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/support') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/support";
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}}/supporthttp GET {{baseUrl}}/supportwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/supportimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/support")! 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()
DELETE
Delete-Media
{{baseUrl}}/media/:MediaId
QUERY PARAMS
MediaId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/media/:MediaId");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/media/:MediaId")require "http/client"
url = "{{baseUrl}}/media/:MediaId"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/media/:MediaId"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/media/:MediaId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/media/:MediaId"
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/media/:MediaId HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/media/:MediaId")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/media/:MediaId"))
.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}}/media/:MediaId")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/media/:MediaId")
.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}}/media/:MediaId');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/media/:MediaId'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/media/:MediaId';
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}}/media/:MediaId',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/media/:MediaId")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/media/:MediaId',
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}}/media/:MediaId'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/media/:MediaId');
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}}/media/:MediaId'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/media/:MediaId';
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}}/media/:MediaId"]
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}}/media/:MediaId" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/media/:MediaId",
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}}/media/:MediaId');
echo $response->getBody();setUrl('{{baseUrl}}/media/:MediaId');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/media/:MediaId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/media/:MediaId' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/media/:MediaId' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/media/:MediaId")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/media/:MediaId"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/media/:MediaId"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/media/:MediaId")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/media/:MediaId') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/media/:MediaId";
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}}/media/:MediaIdhttp DELETE {{baseUrl}}/media/:MediaIdwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/media/:MediaIdimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/media/:MediaId")! 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
Download-Media
{{baseUrl}}/media/:MediaId
QUERY PARAMS
MediaId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/media/:MediaId");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/media/:MediaId")require "http/client"
url = "{{baseUrl}}/media/:MediaId"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/media/:MediaId"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/media/:MediaId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/media/:MediaId"
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/media/:MediaId HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/media/:MediaId")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/media/:MediaId"))
.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}}/media/:MediaId")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/media/:MediaId")
.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}}/media/:MediaId');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/media/:MediaId'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/media/:MediaId';
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}}/media/:MediaId',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/media/:MediaId")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/media/:MediaId',
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}}/media/:MediaId'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/media/:MediaId');
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}}/media/:MediaId'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/media/:MediaId';
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}}/media/:MediaId"]
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}}/media/:MediaId" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/media/:MediaId",
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}}/media/:MediaId');
echo $response->getBody();setUrl('{{baseUrl}}/media/:MediaId');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/media/:MediaId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/media/:MediaId' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/media/:MediaId' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/media/:MediaId")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/media/:MediaId"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/media/:MediaId"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/media/:MediaId")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/media/:MediaId') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/media/:MediaId";
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}}/media/:MediaIdhttp GET {{baseUrl}}/media/:MediaIdwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/media/:MediaIdimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/media/:MediaId")! 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
Upload-Media
{{baseUrl}}/media
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/media");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/media")require "http/client"
url = "{{baseUrl}}/media"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/media"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/media");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/media"
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/media HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/media")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/media"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/media")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/media")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/media');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/media'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/media';
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}}/media',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/media")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/media',
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}}/media'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/media');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'POST', url: '{{baseUrl}}/media'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/media';
const options = {method: 'POST'};
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}}/media"]
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}}/media" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/media",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/media');
echo $response->getBody();setUrl('{{baseUrl}}/media');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/media');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/media' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/media' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/media")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/media"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/media"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/media")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/media') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/media";
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}}/mediahttp POST {{baseUrl}}/mediawget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/mediaimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/media")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"media": [
{
"id": "f043afd0-f0ae-4b9c-ab3d-696fb4c8cd68"
}
]
}
PUT
Mark-Message-As-Read
{{baseUrl}}/messages/:MessageID
QUERY PARAMS
MessageID
BODY json
{
"status": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messages/:MessageID");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"status\": \"read\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/messages/:MessageID" {:content-type :json
:form-params {:status "read"}})require "http/client"
url = "{{baseUrl}}/messages/:MessageID"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"status\": \"read\"\n}"
response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/messages/:MessageID"),
Content = new StringContent("{\n \"status\": \"read\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/messages/:MessageID");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"status\": \"read\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/messages/:MessageID"
payload := strings.NewReader("{\n \"status\": \"read\"\n}")
req, _ := http.NewRequest("PUT", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/messages/:MessageID HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 22
{
"status": "read"
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/messages/:MessageID")
.setHeader("content-type", "application/json")
.setBody("{\n \"status\": \"read\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/messages/:MessageID"))
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("{\n \"status\": \"read\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"status\": \"read\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/messages/:MessageID")
.put(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/messages/:MessageID")
.header("content-type", "application/json")
.body("{\n \"status\": \"read\"\n}")
.asString(); const data = JSON.stringify({
status: 'read'
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/messages/:MessageID');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/messages/:MessageID',
headers: {'content-type': 'application/json'},
data: {status: 'read'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/messages/:MessageID';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"status":"read"}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/messages/:MessageID',
method: 'PUT',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "status": "read"\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"status\": \"read\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/messages/:MessageID")
.put(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/messages/:MessageID',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({status: 'read'}));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/messages/:MessageID',
headers: {'content-type': 'application/json'},
body: {status: 'read'},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/messages/:MessageID');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
status: 'read'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/messages/:MessageID',
headers: {'content-type': 'application/json'},
data: {status: 'read'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/messages/:MessageID';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"status":"read"}'
};
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/json" };
NSDictionary *parameters = @{ @"status": @"read" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/messages/:MessageID"]
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}}/messages/:MessageID" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"status\": \"read\"\n}" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/messages/:MessageID",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
'status' => 'read'
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/messages/:MessageID', [
'body' => '{
"status": "read"
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/messages/:MessageID');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'status' => 'read'
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'status' => 'read'
]));
$request->setRequestUrl('{{baseUrl}}/messages/:MessageID');
$request->setRequestMethod('PUT');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/messages/:MessageID' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"status": "read"
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/messages/:MessageID' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"status": "read"
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"status\": \"read\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PUT", "/baseUrl/messages/:MessageID", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/messages/:MessageID"
payload = { "status": "read" }
headers = {"content-type": "application/json"}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/messages/:MessageID"
payload <- "{\n \"status\": \"read\"\n}"
encode <- "json"
response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/messages/:MessageID")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"status\": \"read\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.put('/baseUrl/messages/:MessageID') do |req|
req.body = "{\n \"status\": \"read\"\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/messages/:MessageID";
let payload = json!({"status": "read"});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/messages/:MessageID \
--header 'content-type: application/json' \
--data '{
"status": "read"
}'echo '{
"status": "read"
}' | \
http PUT {{baseUrl}}/messages/:MessageID \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'content-type: application/json' \
--body-data '{\n "status": "read"\n}' \
--output-document \
- {{baseUrl}}/messages/:MessageIDimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["status": "read"] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messages/:MessageID")! 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
Send-Message
{{baseUrl}}/messages
BODY json
{
"audio": {},
"contacts": [
{
"addresses": [
{
"city": "",
"country": "",
"country_code": "",
"state": "",
"street": "",
"type": "",
"zip": ""
}
],
"birthday": "",
"emails": [
{
"email": "",
"type": ""
}
],
"ims": [],
"name": {
"first_name": "",
"formatted_name": "",
"last_name": "",
"prefix": "",
"suffix": ""
},
"org": {
"company": "",
"department": "",
"title": ""
},
"phones": [
{
"phone": "",
"type": "",
"wa_id": ""
}
],
"urls": [
{
"type": "",
"url": ""
}
]
}
],
"document": {},
"hsm": {
"element_name": "",
"language": {
"code": "",
"policy": ""
},
"localizable_params": [
{
"currency": {
"amount_1000": 0,
"currency_code": ""
},
"date_time": {
"component": {
"day_of_month": 0,
"day_of_week": 0,
"hour": 0,
"minute": 0,
"month": 0,
"year": 0
},
"unix_epoch": {
"timestamp": 0
}
},
"default": ""
}
],
"namespace": ""
},
"image": {},
"location": {
"address": "",
"latitude": "",
"longitude": "",
"name": ""
},
"preview_url": false,
"recipient_type": "",
"text": {
"body": ""
},
"to": "",
"ttl": {},
"type": "",
"video": {}
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messages");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"audio\": {},\n \"contacts\": [\n {\n \"addresses\": [\n {\n \"city\": \"\",\n \"country\": \"\",\n \"country_code\": \"\",\n \"state\": \"\",\n \"street\": \"\",\n \"type\": \"\",\n \"zip\": \"\"\n }\n ],\n \"birthday\": \"\",\n \"emails\": [\n {\n \"email\": \"\",\n \"type\": \"\"\n }\n ],\n \"ims\": [],\n \"name\": {\n \"first_name\": \"\",\n \"formatted_name\": \"\",\n \"last_name\": \"\",\n \"prefix\": \"\",\n \"suffix\": \"\"\n },\n \"org\": {\n \"company\": \"\",\n \"department\": \"\",\n \"title\": \"\"\n },\n \"phones\": [\n {\n \"phone\": \"\",\n \"type\": \"\",\n \"wa_id\": \"\"\n }\n ],\n \"urls\": [\n {\n \"type\": \"\",\n \"url\": \"\"\n }\n ]\n }\n ],\n \"document\": {},\n \"hsm\": {\n \"element_name\": \"\",\n \"language\": {\n \"code\": \"\",\n \"policy\": \"\"\n },\n \"localizable_params\": [\n {\n \"currency\": {\n \"amount_1000\": 0,\n \"currency_code\": \"\"\n },\n \"date_time\": {\n \"component\": {\n \"day_of_month\": 0,\n \"day_of_week\": 0,\n \"hour\": 0,\n \"minute\": 0,\n \"month\": 0,\n \"year\": 0\n },\n \"unix_epoch\": {\n \"timestamp\": 0\n }\n },\n \"default\": \"\"\n }\n ],\n \"namespace\": \"\"\n },\n \"image\": {},\n \"location\": {\n \"address\": \"\",\n \"latitude\": \"\",\n \"longitude\": \"\",\n \"name\": \"\"\n },\n \"preview_url\": false,\n \"recipient_type\": \"\",\n \"text\": {\n \"body\": \"\"\n },\n \"to\": \"\",\n \"ttl\": {},\n \"type\": \"\",\n \"video\": {}\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/messages" {:content-type :json
:form-params {:audio {}
:contacts [{:addresses [{:city ""
:country ""
:country_code ""
:state ""
:street ""
:type ""
:zip ""}]
:birthday ""
:emails [{:email ""
:type ""}]
:ims []
:name {:first_name ""
:formatted_name ""
:last_name ""
:prefix ""
:suffix ""}
:org {:company ""
:department ""
:title ""}
:phones [{:phone ""
:type ""
:wa_id ""}]
:urls [{:type ""
:url ""}]}]
:document {}
:hsm {:element_name ""
:language {:code ""
:policy ""}
:localizable_params [{:currency {:amount_1000 0
:currency_code ""}
:date_time {:component {:day_of_month 0
:day_of_week 0
:hour 0
:minute 0
:month 0
:year 0}
:unix_epoch {:timestamp 0}}
:default ""}]
:namespace ""}
:image {}
:location {:address ""
:latitude ""
:longitude ""
:name ""}
:preview_url false
:recipient_type ""
:text {:body ""}
:to ""
:ttl {}
:type ""
:video {}}})require "http/client"
url = "{{baseUrl}}/messages"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"audio\": {},\n \"contacts\": [\n {\n \"addresses\": [\n {\n \"city\": \"\",\n \"country\": \"\",\n \"country_code\": \"\",\n \"state\": \"\",\n \"street\": \"\",\n \"type\": \"\",\n \"zip\": \"\"\n }\n ],\n \"birthday\": \"\",\n \"emails\": [\n {\n \"email\": \"\",\n \"type\": \"\"\n }\n ],\n \"ims\": [],\n \"name\": {\n \"first_name\": \"\",\n \"formatted_name\": \"\",\n \"last_name\": \"\",\n \"prefix\": \"\",\n \"suffix\": \"\"\n },\n \"org\": {\n \"company\": \"\",\n \"department\": \"\",\n \"title\": \"\"\n },\n \"phones\": [\n {\n \"phone\": \"\",\n \"type\": \"\",\n \"wa_id\": \"\"\n }\n ],\n \"urls\": [\n {\n \"type\": \"\",\n \"url\": \"\"\n }\n ]\n }\n ],\n \"document\": {},\n \"hsm\": {\n \"element_name\": \"\",\n \"language\": {\n \"code\": \"\",\n \"policy\": \"\"\n },\n \"localizable_params\": [\n {\n \"currency\": {\n \"amount_1000\": 0,\n \"currency_code\": \"\"\n },\n \"date_time\": {\n \"component\": {\n \"day_of_month\": 0,\n \"day_of_week\": 0,\n \"hour\": 0,\n \"minute\": 0,\n \"month\": 0,\n \"year\": 0\n },\n \"unix_epoch\": {\n \"timestamp\": 0\n }\n },\n \"default\": \"\"\n }\n ],\n \"namespace\": \"\"\n },\n \"image\": {},\n \"location\": {\n \"address\": \"\",\n \"latitude\": \"\",\n \"longitude\": \"\",\n \"name\": \"\"\n },\n \"preview_url\": false,\n \"recipient_type\": \"\",\n \"text\": {\n \"body\": \"\"\n },\n \"to\": \"\",\n \"ttl\": {},\n \"type\": \"\",\n \"video\": {}\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/messages"),
Content = new StringContent("{\n \"audio\": {},\n \"contacts\": [\n {\n \"addresses\": [\n {\n \"city\": \"\",\n \"country\": \"\",\n \"country_code\": \"\",\n \"state\": \"\",\n \"street\": \"\",\n \"type\": \"\",\n \"zip\": \"\"\n }\n ],\n \"birthday\": \"\",\n \"emails\": [\n {\n \"email\": \"\",\n \"type\": \"\"\n }\n ],\n \"ims\": [],\n \"name\": {\n \"first_name\": \"\",\n \"formatted_name\": \"\",\n \"last_name\": \"\",\n \"prefix\": \"\",\n \"suffix\": \"\"\n },\n \"org\": {\n \"company\": \"\",\n \"department\": \"\",\n \"title\": \"\"\n },\n \"phones\": [\n {\n \"phone\": \"\",\n \"type\": \"\",\n \"wa_id\": \"\"\n }\n ],\n \"urls\": [\n {\n \"type\": \"\",\n \"url\": \"\"\n }\n ]\n }\n ],\n \"document\": {},\n \"hsm\": {\n \"element_name\": \"\",\n \"language\": {\n \"code\": \"\",\n \"policy\": \"\"\n },\n \"localizable_params\": [\n {\n \"currency\": {\n \"amount_1000\": 0,\n \"currency_code\": \"\"\n },\n \"date_time\": {\n \"component\": {\n \"day_of_month\": 0,\n \"day_of_week\": 0,\n \"hour\": 0,\n \"minute\": 0,\n \"month\": 0,\n \"year\": 0\n },\n \"unix_epoch\": {\n \"timestamp\": 0\n }\n },\n \"default\": \"\"\n }\n ],\n \"namespace\": \"\"\n },\n \"image\": {},\n \"location\": {\n \"address\": \"\",\n \"latitude\": \"\",\n \"longitude\": \"\",\n \"name\": \"\"\n },\n \"preview_url\": false,\n \"recipient_type\": \"\",\n \"text\": {\n \"body\": \"\"\n },\n \"to\": \"\",\n \"ttl\": {},\n \"type\": \"\",\n \"video\": {}\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/messages");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"audio\": {},\n \"contacts\": [\n {\n \"addresses\": [\n {\n \"city\": \"\",\n \"country\": \"\",\n \"country_code\": \"\",\n \"state\": \"\",\n \"street\": \"\",\n \"type\": \"\",\n \"zip\": \"\"\n }\n ],\n \"birthday\": \"\",\n \"emails\": [\n {\n \"email\": \"\",\n \"type\": \"\"\n }\n ],\n \"ims\": [],\n \"name\": {\n \"first_name\": \"\",\n \"formatted_name\": \"\",\n \"last_name\": \"\",\n \"prefix\": \"\",\n \"suffix\": \"\"\n },\n \"org\": {\n \"company\": \"\",\n \"department\": \"\",\n \"title\": \"\"\n },\n \"phones\": [\n {\n \"phone\": \"\",\n \"type\": \"\",\n \"wa_id\": \"\"\n }\n ],\n \"urls\": [\n {\n \"type\": \"\",\n \"url\": \"\"\n }\n ]\n }\n ],\n \"document\": {},\n \"hsm\": {\n \"element_name\": \"\",\n \"language\": {\n \"code\": \"\",\n \"policy\": \"\"\n },\n \"localizable_params\": [\n {\n \"currency\": {\n \"amount_1000\": 0,\n \"currency_code\": \"\"\n },\n \"date_time\": {\n \"component\": {\n \"day_of_month\": 0,\n \"day_of_week\": 0,\n \"hour\": 0,\n \"minute\": 0,\n \"month\": 0,\n \"year\": 0\n },\n \"unix_epoch\": {\n \"timestamp\": 0\n }\n },\n \"default\": \"\"\n }\n ],\n \"namespace\": \"\"\n },\n \"image\": {},\n \"location\": {\n \"address\": \"\",\n \"latitude\": \"\",\n \"longitude\": \"\",\n \"name\": \"\"\n },\n \"preview_url\": false,\n \"recipient_type\": \"\",\n \"text\": {\n \"body\": \"\"\n },\n \"to\": \"\",\n \"ttl\": {},\n \"type\": \"\",\n \"video\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/messages"
payload := strings.NewReader("{\n \"audio\": {},\n \"contacts\": [\n {\n \"addresses\": [\n {\n \"city\": \"\",\n \"country\": \"\",\n \"country_code\": \"\",\n \"state\": \"\",\n \"street\": \"\",\n \"type\": \"\",\n \"zip\": \"\"\n }\n ],\n \"birthday\": \"\",\n \"emails\": [\n {\n \"email\": \"\",\n \"type\": \"\"\n }\n ],\n \"ims\": [],\n \"name\": {\n \"first_name\": \"\",\n \"formatted_name\": \"\",\n \"last_name\": \"\",\n \"prefix\": \"\",\n \"suffix\": \"\"\n },\n \"org\": {\n \"company\": \"\",\n \"department\": \"\",\n \"title\": \"\"\n },\n \"phones\": [\n {\n \"phone\": \"\",\n \"type\": \"\",\n \"wa_id\": \"\"\n }\n ],\n \"urls\": [\n {\n \"type\": \"\",\n \"url\": \"\"\n }\n ]\n }\n ],\n \"document\": {},\n \"hsm\": {\n \"element_name\": \"\",\n \"language\": {\n \"code\": \"\",\n \"policy\": \"\"\n },\n \"localizable_params\": [\n {\n \"currency\": {\n \"amount_1000\": 0,\n \"currency_code\": \"\"\n },\n \"date_time\": {\n \"component\": {\n \"day_of_month\": 0,\n \"day_of_week\": 0,\n \"hour\": 0,\n \"minute\": 0,\n \"month\": 0,\n \"year\": 0\n },\n \"unix_epoch\": {\n \"timestamp\": 0\n }\n },\n \"default\": \"\"\n }\n ],\n \"namespace\": \"\"\n },\n \"image\": {},\n \"location\": {\n \"address\": \"\",\n \"latitude\": \"\",\n \"longitude\": \"\",\n \"name\": \"\"\n },\n \"preview_url\": false,\n \"recipient_type\": \"\",\n \"text\": {\n \"body\": \"\"\n },\n \"to\": \"\",\n \"ttl\": {},\n \"type\": \"\",\n \"video\": {}\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/messages HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1679
{
"audio": {},
"contacts": [
{
"addresses": [
{
"city": "",
"country": "",
"country_code": "",
"state": "",
"street": "",
"type": "",
"zip": ""
}
],
"birthday": "",
"emails": [
{
"email": "",
"type": ""
}
],
"ims": [],
"name": {
"first_name": "",
"formatted_name": "",
"last_name": "",
"prefix": "",
"suffix": ""
},
"org": {
"company": "",
"department": "",
"title": ""
},
"phones": [
{
"phone": "",
"type": "",
"wa_id": ""
}
],
"urls": [
{
"type": "",
"url": ""
}
]
}
],
"document": {},
"hsm": {
"element_name": "",
"language": {
"code": "",
"policy": ""
},
"localizable_params": [
{
"currency": {
"amount_1000": 0,
"currency_code": ""
},
"date_time": {
"component": {
"day_of_month": 0,
"day_of_week": 0,
"hour": 0,
"minute": 0,
"month": 0,
"year": 0
},
"unix_epoch": {
"timestamp": 0
}
},
"default": ""
}
],
"namespace": ""
},
"image": {},
"location": {
"address": "",
"latitude": "",
"longitude": "",
"name": ""
},
"preview_url": false,
"recipient_type": "",
"text": {
"body": ""
},
"to": "",
"ttl": {},
"type": "",
"video": {}
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/messages")
.setHeader("content-type", "application/json")
.setBody("{\n \"audio\": {},\n \"contacts\": [\n {\n \"addresses\": [\n {\n \"city\": \"\",\n \"country\": \"\",\n \"country_code\": \"\",\n \"state\": \"\",\n \"street\": \"\",\n \"type\": \"\",\n \"zip\": \"\"\n }\n ],\n \"birthday\": \"\",\n \"emails\": [\n {\n \"email\": \"\",\n \"type\": \"\"\n }\n ],\n \"ims\": [],\n \"name\": {\n \"first_name\": \"\",\n \"formatted_name\": \"\",\n \"last_name\": \"\",\n \"prefix\": \"\",\n \"suffix\": \"\"\n },\n \"org\": {\n \"company\": \"\",\n \"department\": \"\",\n \"title\": \"\"\n },\n \"phones\": [\n {\n \"phone\": \"\",\n \"type\": \"\",\n \"wa_id\": \"\"\n }\n ],\n \"urls\": [\n {\n \"type\": \"\",\n \"url\": \"\"\n }\n ]\n }\n ],\n \"document\": {},\n \"hsm\": {\n \"element_name\": \"\",\n \"language\": {\n \"code\": \"\",\n \"policy\": \"\"\n },\n \"localizable_params\": [\n {\n \"currency\": {\n \"amount_1000\": 0,\n \"currency_code\": \"\"\n },\n \"date_time\": {\n \"component\": {\n \"day_of_month\": 0,\n \"day_of_week\": 0,\n \"hour\": 0,\n \"minute\": 0,\n \"month\": 0,\n \"year\": 0\n },\n \"unix_epoch\": {\n \"timestamp\": 0\n }\n },\n \"default\": \"\"\n }\n ],\n \"namespace\": \"\"\n },\n \"image\": {},\n \"location\": {\n \"address\": \"\",\n \"latitude\": \"\",\n \"longitude\": \"\",\n \"name\": \"\"\n },\n \"preview_url\": false,\n \"recipient_type\": \"\",\n \"text\": {\n \"body\": \"\"\n },\n \"to\": \"\",\n \"ttl\": {},\n \"type\": \"\",\n \"video\": {}\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/messages"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"audio\": {},\n \"contacts\": [\n {\n \"addresses\": [\n {\n \"city\": \"\",\n \"country\": \"\",\n \"country_code\": \"\",\n \"state\": \"\",\n \"street\": \"\",\n \"type\": \"\",\n \"zip\": \"\"\n }\n ],\n \"birthday\": \"\",\n \"emails\": [\n {\n \"email\": \"\",\n \"type\": \"\"\n }\n ],\n \"ims\": [],\n \"name\": {\n \"first_name\": \"\",\n \"formatted_name\": \"\",\n \"last_name\": \"\",\n \"prefix\": \"\",\n \"suffix\": \"\"\n },\n \"org\": {\n \"company\": \"\",\n \"department\": \"\",\n \"title\": \"\"\n },\n \"phones\": [\n {\n \"phone\": \"\",\n \"type\": \"\",\n \"wa_id\": \"\"\n }\n ],\n \"urls\": [\n {\n \"type\": \"\",\n \"url\": \"\"\n }\n ]\n }\n ],\n \"document\": {},\n \"hsm\": {\n \"element_name\": \"\",\n \"language\": {\n \"code\": \"\",\n \"policy\": \"\"\n },\n \"localizable_params\": [\n {\n \"currency\": {\n \"amount_1000\": 0,\n \"currency_code\": \"\"\n },\n \"date_time\": {\n \"component\": {\n \"day_of_month\": 0,\n \"day_of_week\": 0,\n \"hour\": 0,\n \"minute\": 0,\n \"month\": 0,\n \"year\": 0\n },\n \"unix_epoch\": {\n \"timestamp\": 0\n }\n },\n \"default\": \"\"\n }\n ],\n \"namespace\": \"\"\n },\n \"image\": {},\n \"location\": {\n \"address\": \"\",\n \"latitude\": \"\",\n \"longitude\": \"\",\n \"name\": \"\"\n },\n \"preview_url\": false,\n \"recipient_type\": \"\",\n \"text\": {\n \"body\": \"\"\n },\n \"to\": \"\",\n \"ttl\": {},\n \"type\": \"\",\n \"video\": {}\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"audio\": {},\n \"contacts\": [\n {\n \"addresses\": [\n {\n \"city\": \"\",\n \"country\": \"\",\n \"country_code\": \"\",\n \"state\": \"\",\n \"street\": \"\",\n \"type\": \"\",\n \"zip\": \"\"\n }\n ],\n \"birthday\": \"\",\n \"emails\": [\n {\n \"email\": \"\",\n \"type\": \"\"\n }\n ],\n \"ims\": [],\n \"name\": {\n \"first_name\": \"\",\n \"formatted_name\": \"\",\n \"last_name\": \"\",\n \"prefix\": \"\",\n \"suffix\": \"\"\n },\n \"org\": {\n \"company\": \"\",\n \"department\": \"\",\n \"title\": \"\"\n },\n \"phones\": [\n {\n \"phone\": \"\",\n \"type\": \"\",\n \"wa_id\": \"\"\n }\n ],\n \"urls\": [\n {\n \"type\": \"\",\n \"url\": \"\"\n }\n ]\n }\n ],\n \"document\": {},\n \"hsm\": {\n \"element_name\": \"\",\n \"language\": {\n \"code\": \"\",\n \"policy\": \"\"\n },\n \"localizable_params\": [\n {\n \"currency\": {\n \"amount_1000\": 0,\n \"currency_code\": \"\"\n },\n \"date_time\": {\n \"component\": {\n \"day_of_month\": 0,\n \"day_of_week\": 0,\n \"hour\": 0,\n \"minute\": 0,\n \"month\": 0,\n \"year\": 0\n },\n \"unix_epoch\": {\n \"timestamp\": 0\n }\n },\n \"default\": \"\"\n }\n ],\n \"namespace\": \"\"\n },\n \"image\": {},\n \"location\": {\n \"address\": \"\",\n \"latitude\": \"\",\n \"longitude\": \"\",\n \"name\": \"\"\n },\n \"preview_url\": false,\n \"recipient_type\": \"\",\n \"text\": {\n \"body\": \"\"\n },\n \"to\": \"\",\n \"ttl\": {},\n \"type\": \"\",\n \"video\": {}\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/messages")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/messages")
.header("content-type", "application/json")
.body("{\n \"audio\": {},\n \"contacts\": [\n {\n \"addresses\": [\n {\n \"city\": \"\",\n \"country\": \"\",\n \"country_code\": \"\",\n \"state\": \"\",\n \"street\": \"\",\n \"type\": \"\",\n \"zip\": \"\"\n }\n ],\n \"birthday\": \"\",\n \"emails\": [\n {\n \"email\": \"\",\n \"type\": \"\"\n }\n ],\n \"ims\": [],\n \"name\": {\n \"first_name\": \"\",\n \"formatted_name\": \"\",\n \"last_name\": \"\",\n \"prefix\": \"\",\n \"suffix\": \"\"\n },\n \"org\": {\n \"company\": \"\",\n \"department\": \"\",\n \"title\": \"\"\n },\n \"phones\": [\n {\n \"phone\": \"\",\n \"type\": \"\",\n \"wa_id\": \"\"\n }\n ],\n \"urls\": [\n {\n \"type\": \"\",\n \"url\": \"\"\n }\n ]\n }\n ],\n \"document\": {},\n \"hsm\": {\n \"element_name\": \"\",\n \"language\": {\n \"code\": \"\",\n \"policy\": \"\"\n },\n \"localizable_params\": [\n {\n \"currency\": {\n \"amount_1000\": 0,\n \"currency_code\": \"\"\n },\n \"date_time\": {\n \"component\": {\n \"day_of_month\": 0,\n \"day_of_week\": 0,\n \"hour\": 0,\n \"minute\": 0,\n \"month\": 0,\n \"year\": 0\n },\n \"unix_epoch\": {\n \"timestamp\": 0\n }\n },\n \"default\": \"\"\n }\n ],\n \"namespace\": \"\"\n },\n \"image\": {},\n \"location\": {\n \"address\": \"\",\n \"latitude\": \"\",\n \"longitude\": \"\",\n \"name\": \"\"\n },\n \"preview_url\": false,\n \"recipient_type\": \"\",\n \"text\": {\n \"body\": \"\"\n },\n \"to\": \"\",\n \"ttl\": {},\n \"type\": \"\",\n \"video\": {}\n}")
.asString(); const data = JSON.stringify({
audio: {},
contacts: [
{
addresses: [
{
city: '',
country: '',
country_code: '',
state: '',
street: '',
type: '',
zip: ''
}
],
birthday: '',
emails: [
{
email: '',
type: ''
}
],
ims: [],
name: {
first_name: '',
formatted_name: '',
last_name: '',
prefix: '',
suffix: ''
},
org: {
company: '',
department: '',
title: ''
},
phones: [
{
phone: '',
type: '',
wa_id: ''
}
],
urls: [
{
type: '',
url: ''
}
]
}
],
document: {},
hsm: {
element_name: '',
language: {
code: '',
policy: ''
},
localizable_params: [
{
currency: {
amount_1000: 0,
currency_code: ''
},
date_time: {
component: {
day_of_month: 0,
day_of_week: 0,
hour: 0,
minute: 0,
month: 0,
year: 0
},
unix_epoch: {
timestamp: 0
}
},
default: ''
}
],
namespace: ''
},
image: {},
location: {
address: '',
latitude: '',
longitude: '',
name: ''
},
preview_url: false,
recipient_type: '',
text: {
body: ''
},
to: '',
ttl: {},
type: '',
video: {}
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/messages');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/messages',
headers: {'content-type': 'application/json'},
data: {
audio: {},
contacts: [
{
addresses: [
{
city: '',
country: '',
country_code: '',
state: '',
street: '',
type: '',
zip: ''
}
],
birthday: '',
emails: [{email: '', type: ''}],
ims: [],
name: {first_name: '', formatted_name: '', last_name: '', prefix: '', suffix: ''},
org: {company: '', department: '', title: ''},
phones: [{phone: '', type: '', wa_id: ''}],
urls: [{type: '', url: ''}]
}
],
document: {},
hsm: {
element_name: '',
language: {code: '', policy: ''},
localizable_params: [
{
currency: {amount_1000: 0, currency_code: ''},
date_time: {
component: {day_of_month: 0, day_of_week: 0, hour: 0, minute: 0, month: 0, year: 0},
unix_epoch: {timestamp: 0}
},
default: ''
}
],
namespace: ''
},
image: {},
location: {address: '', latitude: '', longitude: '', name: ''},
preview_url: false,
recipient_type: '',
text: {body: ''},
to: '',
ttl: {},
type: '',
video: {}
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/messages';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"audio":{},"contacts":[{"addresses":[{"city":"","country":"","country_code":"","state":"","street":"","type":"","zip":""}],"birthday":"","emails":[{"email":"","type":""}],"ims":[],"name":{"first_name":"","formatted_name":"","last_name":"","prefix":"","suffix":""},"org":{"company":"","department":"","title":""},"phones":[{"phone":"","type":"","wa_id":""}],"urls":[{"type":"","url":""}]}],"document":{},"hsm":{"element_name":"","language":{"code":"","policy":""},"localizable_params":[{"currency":{"amount_1000":0,"currency_code":""},"date_time":{"component":{"day_of_month":0,"day_of_week":0,"hour":0,"minute":0,"month":0,"year":0},"unix_epoch":{"timestamp":0}},"default":""}],"namespace":""},"image":{},"location":{"address":"","latitude":"","longitude":"","name":""},"preview_url":false,"recipient_type":"","text":{"body":""},"to":"","ttl":{},"type":"","video":{}}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/messages',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "audio": {},\n "contacts": [\n {\n "addresses": [\n {\n "city": "",\n "country": "",\n "country_code": "",\n "state": "",\n "street": "",\n "type": "",\n "zip": ""\n }\n ],\n "birthday": "",\n "emails": [\n {\n "email": "",\n "type": ""\n }\n ],\n "ims": [],\n "name": {\n "first_name": "",\n "formatted_name": "",\n "last_name": "",\n "prefix": "",\n "suffix": ""\n },\n "org": {\n "company": "",\n "department": "",\n "title": ""\n },\n "phones": [\n {\n "phone": "",\n "type": "",\n "wa_id": ""\n }\n ],\n "urls": [\n {\n "type": "",\n "url": ""\n }\n ]\n }\n ],\n "document": {},\n "hsm": {\n "element_name": "",\n "language": {\n "code": "",\n "policy": ""\n },\n "localizable_params": [\n {\n "currency": {\n "amount_1000": 0,\n "currency_code": ""\n },\n "date_time": {\n "component": {\n "day_of_month": 0,\n "day_of_week": 0,\n "hour": 0,\n "minute": 0,\n "month": 0,\n "year": 0\n },\n "unix_epoch": {\n "timestamp": 0\n }\n },\n "default": ""\n }\n ],\n "namespace": ""\n },\n "image": {},\n "location": {\n "address": "",\n "latitude": "",\n "longitude": "",\n "name": ""\n },\n "preview_url": false,\n "recipient_type": "",\n "text": {\n "body": ""\n },\n "to": "",\n "ttl": {},\n "type": "",\n "video": {}\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"audio\": {},\n \"contacts\": [\n {\n \"addresses\": [\n {\n \"city\": \"\",\n \"country\": \"\",\n \"country_code\": \"\",\n \"state\": \"\",\n \"street\": \"\",\n \"type\": \"\",\n \"zip\": \"\"\n }\n ],\n \"birthday\": \"\",\n \"emails\": [\n {\n \"email\": \"\",\n \"type\": \"\"\n }\n ],\n \"ims\": [],\n \"name\": {\n \"first_name\": \"\",\n \"formatted_name\": \"\",\n \"last_name\": \"\",\n \"prefix\": \"\",\n \"suffix\": \"\"\n },\n \"org\": {\n \"company\": \"\",\n \"department\": \"\",\n \"title\": \"\"\n },\n \"phones\": [\n {\n \"phone\": \"\",\n \"type\": \"\",\n \"wa_id\": \"\"\n }\n ],\n \"urls\": [\n {\n \"type\": \"\",\n \"url\": \"\"\n }\n ]\n }\n ],\n \"document\": {},\n \"hsm\": {\n \"element_name\": \"\",\n \"language\": {\n \"code\": \"\",\n \"policy\": \"\"\n },\n \"localizable_params\": [\n {\n \"currency\": {\n \"amount_1000\": 0,\n \"currency_code\": \"\"\n },\n \"date_time\": {\n \"component\": {\n \"day_of_month\": 0,\n \"day_of_week\": 0,\n \"hour\": 0,\n \"minute\": 0,\n \"month\": 0,\n \"year\": 0\n },\n \"unix_epoch\": {\n \"timestamp\": 0\n }\n },\n \"default\": \"\"\n }\n ],\n \"namespace\": \"\"\n },\n \"image\": {},\n \"location\": {\n \"address\": \"\",\n \"latitude\": \"\",\n \"longitude\": \"\",\n \"name\": \"\"\n },\n \"preview_url\": false,\n \"recipient_type\": \"\",\n \"text\": {\n \"body\": \"\"\n },\n \"to\": \"\",\n \"ttl\": {},\n \"type\": \"\",\n \"video\": {}\n}")
val request = Request.Builder()
.url("{{baseUrl}}/messages")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/messages',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
audio: {},
contacts: [
{
addresses: [
{
city: '',
country: '',
country_code: '',
state: '',
street: '',
type: '',
zip: ''
}
],
birthday: '',
emails: [{email: '', type: ''}],
ims: [],
name: {first_name: '', formatted_name: '', last_name: '', prefix: '', suffix: ''},
org: {company: '', department: '', title: ''},
phones: [{phone: '', type: '', wa_id: ''}],
urls: [{type: '', url: ''}]
}
],
document: {},
hsm: {
element_name: '',
language: {code: '', policy: ''},
localizable_params: [
{
currency: {amount_1000: 0, currency_code: ''},
date_time: {
component: {day_of_month: 0, day_of_week: 0, hour: 0, minute: 0, month: 0, year: 0},
unix_epoch: {timestamp: 0}
},
default: ''
}
],
namespace: ''
},
image: {},
location: {address: '', latitude: '', longitude: '', name: ''},
preview_url: false,
recipient_type: '',
text: {body: ''},
to: '',
ttl: {},
type: '',
video: {}
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/messages',
headers: {'content-type': 'application/json'},
body: {
audio: {},
contacts: [
{
addresses: [
{
city: '',
country: '',
country_code: '',
state: '',
street: '',
type: '',
zip: ''
}
],
birthday: '',
emails: [{email: '', type: ''}],
ims: [],
name: {first_name: '', formatted_name: '', last_name: '', prefix: '', suffix: ''},
org: {company: '', department: '', title: ''},
phones: [{phone: '', type: '', wa_id: ''}],
urls: [{type: '', url: ''}]
}
],
document: {},
hsm: {
element_name: '',
language: {code: '', policy: ''},
localizable_params: [
{
currency: {amount_1000: 0, currency_code: ''},
date_time: {
component: {day_of_month: 0, day_of_week: 0, hour: 0, minute: 0, month: 0, year: 0},
unix_epoch: {timestamp: 0}
},
default: ''
}
],
namespace: ''
},
image: {},
location: {address: '', latitude: '', longitude: '', name: ''},
preview_url: false,
recipient_type: '',
text: {body: ''},
to: '',
ttl: {},
type: '',
video: {}
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/messages');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
audio: {},
contacts: [
{
addresses: [
{
city: '',
country: '',
country_code: '',
state: '',
street: '',
type: '',
zip: ''
}
],
birthday: '',
emails: [
{
email: '',
type: ''
}
],
ims: [],
name: {
first_name: '',
formatted_name: '',
last_name: '',
prefix: '',
suffix: ''
},
org: {
company: '',
department: '',
title: ''
},
phones: [
{
phone: '',
type: '',
wa_id: ''
}
],
urls: [
{
type: '',
url: ''
}
]
}
],
document: {},
hsm: {
element_name: '',
language: {
code: '',
policy: ''
},
localizable_params: [
{
currency: {
amount_1000: 0,
currency_code: ''
},
date_time: {
component: {
day_of_month: 0,
day_of_week: 0,
hour: 0,
minute: 0,
month: 0,
year: 0
},
unix_epoch: {
timestamp: 0
}
},
default: ''
}
],
namespace: ''
},
image: {},
location: {
address: '',
latitude: '',
longitude: '',
name: ''
},
preview_url: false,
recipient_type: '',
text: {
body: ''
},
to: '',
ttl: {},
type: '',
video: {}
});
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}}/messages',
headers: {'content-type': 'application/json'},
data: {
audio: {},
contacts: [
{
addresses: [
{
city: '',
country: '',
country_code: '',
state: '',
street: '',
type: '',
zip: ''
}
],
birthday: '',
emails: [{email: '', type: ''}],
ims: [],
name: {first_name: '', formatted_name: '', last_name: '', prefix: '', suffix: ''},
org: {company: '', department: '', title: ''},
phones: [{phone: '', type: '', wa_id: ''}],
urls: [{type: '', url: ''}]
}
],
document: {},
hsm: {
element_name: '',
language: {code: '', policy: ''},
localizable_params: [
{
currency: {amount_1000: 0, currency_code: ''},
date_time: {
component: {day_of_month: 0, day_of_week: 0, hour: 0, minute: 0, month: 0, year: 0},
unix_epoch: {timestamp: 0}
},
default: ''
}
],
namespace: ''
},
image: {},
location: {address: '', latitude: '', longitude: '', name: ''},
preview_url: false,
recipient_type: '',
text: {body: ''},
to: '',
ttl: {},
type: '',
video: {}
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/messages';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"audio":{},"contacts":[{"addresses":[{"city":"","country":"","country_code":"","state":"","street":"","type":"","zip":""}],"birthday":"","emails":[{"email":"","type":""}],"ims":[],"name":{"first_name":"","formatted_name":"","last_name":"","prefix":"","suffix":""},"org":{"company":"","department":"","title":""},"phones":[{"phone":"","type":"","wa_id":""}],"urls":[{"type":"","url":""}]}],"document":{},"hsm":{"element_name":"","language":{"code":"","policy":""},"localizable_params":[{"currency":{"amount_1000":0,"currency_code":""},"date_time":{"component":{"day_of_month":0,"day_of_week":0,"hour":0,"minute":0,"month":0,"year":0},"unix_epoch":{"timestamp":0}},"default":""}],"namespace":""},"image":{},"location":{"address":"","latitude":"","longitude":"","name":""},"preview_url":false,"recipient_type":"","text":{"body":""},"to":"","ttl":{},"type":"","video":{}}'
};
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/json" };
NSDictionary *parameters = @{ @"audio": @{ },
@"contacts": @[ @{ @"addresses": @[ @{ @"city": @"", @"country": @"", @"country_code": @"", @"state": @"", @"street": @"", @"type": @"", @"zip": @"" } ], @"birthday": @"", @"emails": @[ @{ @"email": @"", @"type": @"" } ], @"ims": @[ ], @"name": @{ @"first_name": @"", @"formatted_name": @"", @"last_name": @"", @"prefix": @"", @"suffix": @"" }, @"org": @{ @"company": @"", @"department": @"", @"title": @"" }, @"phones": @[ @{ @"phone": @"", @"type": @"", @"wa_id": @"" } ], @"urls": @[ @{ @"type": @"", @"url": @"" } ] } ],
@"document": @{ },
@"hsm": @{ @"element_name": @"", @"language": @{ @"code": @"", @"policy": @"" }, @"localizable_params": @[ @{ @"currency": @{ @"amount_1000": @0, @"currency_code": @"" }, @"date_time": @{ @"component": @{ @"day_of_month": @0, @"day_of_week": @0, @"hour": @0, @"minute": @0, @"month": @0, @"year": @0 }, @"unix_epoch": @{ @"timestamp": @0 } }, @"default": @"" } ], @"namespace": @"" },
@"image": @{ },
@"location": @{ @"address": @"", @"latitude": @"", @"longitude": @"", @"name": @"" },
@"preview_url": @NO,
@"recipient_type": @"",
@"text": @{ @"body": @"" },
@"to": @"",
@"ttl": @{ },
@"type": @"",
@"video": @{ } };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/messages"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/messages" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"audio\": {},\n \"contacts\": [\n {\n \"addresses\": [\n {\n \"city\": \"\",\n \"country\": \"\",\n \"country_code\": \"\",\n \"state\": \"\",\n \"street\": \"\",\n \"type\": \"\",\n \"zip\": \"\"\n }\n ],\n \"birthday\": \"\",\n \"emails\": [\n {\n \"email\": \"\",\n \"type\": \"\"\n }\n ],\n \"ims\": [],\n \"name\": {\n \"first_name\": \"\",\n \"formatted_name\": \"\",\n \"last_name\": \"\",\n \"prefix\": \"\",\n \"suffix\": \"\"\n },\n \"org\": {\n \"company\": \"\",\n \"department\": \"\",\n \"title\": \"\"\n },\n \"phones\": [\n {\n \"phone\": \"\",\n \"type\": \"\",\n \"wa_id\": \"\"\n }\n ],\n \"urls\": [\n {\n \"type\": \"\",\n \"url\": \"\"\n }\n ]\n }\n ],\n \"document\": {},\n \"hsm\": {\n \"element_name\": \"\",\n \"language\": {\n \"code\": \"\",\n \"policy\": \"\"\n },\n \"localizable_params\": [\n {\n \"currency\": {\n \"amount_1000\": 0,\n \"currency_code\": \"\"\n },\n \"date_time\": {\n \"component\": {\n \"day_of_month\": 0,\n \"day_of_week\": 0,\n \"hour\": 0,\n \"minute\": 0,\n \"month\": 0,\n \"year\": 0\n },\n \"unix_epoch\": {\n \"timestamp\": 0\n }\n },\n \"default\": \"\"\n }\n ],\n \"namespace\": \"\"\n },\n \"image\": {},\n \"location\": {\n \"address\": \"\",\n \"latitude\": \"\",\n \"longitude\": \"\",\n \"name\": \"\"\n },\n \"preview_url\": false,\n \"recipient_type\": \"\",\n \"text\": {\n \"body\": \"\"\n },\n \"to\": \"\",\n \"ttl\": {},\n \"type\": \"\",\n \"video\": {}\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/messages",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'audio' => [
],
'contacts' => [
[
'addresses' => [
[
'city' => '',
'country' => '',
'country_code' => '',
'state' => '',
'street' => '',
'type' => '',
'zip' => ''
]
],
'birthday' => '',
'emails' => [
[
'email' => '',
'type' => ''
]
],
'ims' => [
],
'name' => [
'first_name' => '',
'formatted_name' => '',
'last_name' => '',
'prefix' => '',
'suffix' => ''
],
'org' => [
'company' => '',
'department' => '',
'title' => ''
],
'phones' => [
[
'phone' => '',
'type' => '',
'wa_id' => ''
]
],
'urls' => [
[
'type' => '',
'url' => ''
]
]
]
],
'document' => [
],
'hsm' => [
'element_name' => '',
'language' => [
'code' => '',
'policy' => ''
],
'localizable_params' => [
[
'currency' => [
'amount_1000' => 0,
'currency_code' => ''
],
'date_time' => [
'component' => [
'day_of_month' => 0,
'day_of_week' => 0,
'hour' => 0,
'minute' => 0,
'month' => 0,
'year' => 0
],
'unix_epoch' => [
'timestamp' => 0
]
],
'default' => ''
]
],
'namespace' => ''
],
'image' => [
],
'location' => [
'address' => '',
'latitude' => '',
'longitude' => '',
'name' => ''
],
'preview_url' => null,
'recipient_type' => '',
'text' => [
'body' => ''
],
'to' => '',
'ttl' => [
],
'type' => '',
'video' => [
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/messages', [
'body' => '{
"audio": {},
"contacts": [
{
"addresses": [
{
"city": "",
"country": "",
"country_code": "",
"state": "",
"street": "",
"type": "",
"zip": ""
}
],
"birthday": "",
"emails": [
{
"email": "",
"type": ""
}
],
"ims": [],
"name": {
"first_name": "",
"formatted_name": "",
"last_name": "",
"prefix": "",
"suffix": ""
},
"org": {
"company": "",
"department": "",
"title": ""
},
"phones": [
{
"phone": "",
"type": "",
"wa_id": ""
}
],
"urls": [
{
"type": "",
"url": ""
}
]
}
],
"document": {},
"hsm": {
"element_name": "",
"language": {
"code": "",
"policy": ""
},
"localizable_params": [
{
"currency": {
"amount_1000": 0,
"currency_code": ""
},
"date_time": {
"component": {
"day_of_month": 0,
"day_of_week": 0,
"hour": 0,
"minute": 0,
"month": 0,
"year": 0
},
"unix_epoch": {
"timestamp": 0
}
},
"default": ""
}
],
"namespace": ""
},
"image": {},
"location": {
"address": "",
"latitude": "",
"longitude": "",
"name": ""
},
"preview_url": false,
"recipient_type": "",
"text": {
"body": ""
},
"to": "",
"ttl": {},
"type": "",
"video": {}
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/messages');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'audio' => [
],
'contacts' => [
[
'addresses' => [
[
'city' => '',
'country' => '',
'country_code' => '',
'state' => '',
'street' => '',
'type' => '',
'zip' => ''
]
],
'birthday' => '',
'emails' => [
[
'email' => '',
'type' => ''
]
],
'ims' => [
],
'name' => [
'first_name' => '',
'formatted_name' => '',
'last_name' => '',
'prefix' => '',
'suffix' => ''
],
'org' => [
'company' => '',
'department' => '',
'title' => ''
],
'phones' => [
[
'phone' => '',
'type' => '',
'wa_id' => ''
]
],
'urls' => [
[
'type' => '',
'url' => ''
]
]
]
],
'document' => [
],
'hsm' => [
'element_name' => '',
'language' => [
'code' => '',
'policy' => ''
],
'localizable_params' => [
[
'currency' => [
'amount_1000' => 0,
'currency_code' => ''
],
'date_time' => [
'component' => [
'day_of_month' => 0,
'day_of_week' => 0,
'hour' => 0,
'minute' => 0,
'month' => 0,
'year' => 0
],
'unix_epoch' => [
'timestamp' => 0
]
],
'default' => ''
]
],
'namespace' => ''
],
'image' => [
],
'location' => [
'address' => '',
'latitude' => '',
'longitude' => '',
'name' => ''
],
'preview_url' => null,
'recipient_type' => '',
'text' => [
'body' => ''
],
'to' => '',
'ttl' => [
],
'type' => '',
'video' => [
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'audio' => [
],
'contacts' => [
[
'addresses' => [
[
'city' => '',
'country' => '',
'country_code' => '',
'state' => '',
'street' => '',
'type' => '',
'zip' => ''
]
],
'birthday' => '',
'emails' => [
[
'email' => '',
'type' => ''
]
],
'ims' => [
],
'name' => [
'first_name' => '',
'formatted_name' => '',
'last_name' => '',
'prefix' => '',
'suffix' => ''
],
'org' => [
'company' => '',
'department' => '',
'title' => ''
],
'phones' => [
[
'phone' => '',
'type' => '',
'wa_id' => ''
]
],
'urls' => [
[
'type' => '',
'url' => ''
]
]
]
],
'document' => [
],
'hsm' => [
'element_name' => '',
'language' => [
'code' => '',
'policy' => ''
],
'localizable_params' => [
[
'currency' => [
'amount_1000' => 0,
'currency_code' => ''
],
'date_time' => [
'component' => [
'day_of_month' => 0,
'day_of_week' => 0,
'hour' => 0,
'minute' => 0,
'month' => 0,
'year' => 0
],
'unix_epoch' => [
'timestamp' => 0
]
],
'default' => ''
]
],
'namespace' => ''
],
'image' => [
],
'location' => [
'address' => '',
'latitude' => '',
'longitude' => '',
'name' => ''
],
'preview_url' => null,
'recipient_type' => '',
'text' => [
'body' => ''
],
'to' => '',
'ttl' => [
],
'type' => '',
'video' => [
]
]));
$request->setRequestUrl('{{baseUrl}}/messages');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/messages' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"audio": {},
"contacts": [
{
"addresses": [
{
"city": "",
"country": "",
"country_code": "",
"state": "",
"street": "",
"type": "",
"zip": ""
}
],
"birthday": "",
"emails": [
{
"email": "",
"type": ""
}
],
"ims": [],
"name": {
"first_name": "",
"formatted_name": "",
"last_name": "",
"prefix": "",
"suffix": ""
},
"org": {
"company": "",
"department": "",
"title": ""
},
"phones": [
{
"phone": "",
"type": "",
"wa_id": ""
}
],
"urls": [
{
"type": "",
"url": ""
}
]
}
],
"document": {},
"hsm": {
"element_name": "",
"language": {
"code": "",
"policy": ""
},
"localizable_params": [
{
"currency": {
"amount_1000": 0,
"currency_code": ""
},
"date_time": {
"component": {
"day_of_month": 0,
"day_of_week": 0,
"hour": 0,
"minute": 0,
"month": 0,
"year": 0
},
"unix_epoch": {
"timestamp": 0
}
},
"default": ""
}
],
"namespace": ""
},
"image": {},
"location": {
"address": "",
"latitude": "",
"longitude": "",
"name": ""
},
"preview_url": false,
"recipient_type": "",
"text": {
"body": ""
},
"to": "",
"ttl": {},
"type": "",
"video": {}
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/messages' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"audio": {},
"contacts": [
{
"addresses": [
{
"city": "",
"country": "",
"country_code": "",
"state": "",
"street": "",
"type": "",
"zip": ""
}
],
"birthday": "",
"emails": [
{
"email": "",
"type": ""
}
],
"ims": [],
"name": {
"first_name": "",
"formatted_name": "",
"last_name": "",
"prefix": "",
"suffix": ""
},
"org": {
"company": "",
"department": "",
"title": ""
},
"phones": [
{
"phone": "",
"type": "",
"wa_id": ""
}
],
"urls": [
{
"type": "",
"url": ""
}
]
}
],
"document": {},
"hsm": {
"element_name": "",
"language": {
"code": "",
"policy": ""
},
"localizable_params": [
{
"currency": {
"amount_1000": 0,
"currency_code": ""
},
"date_time": {
"component": {
"day_of_month": 0,
"day_of_week": 0,
"hour": 0,
"minute": 0,
"month": 0,
"year": 0
},
"unix_epoch": {
"timestamp": 0
}
},
"default": ""
}
],
"namespace": ""
},
"image": {},
"location": {
"address": "",
"latitude": "",
"longitude": "",
"name": ""
},
"preview_url": false,
"recipient_type": "",
"text": {
"body": ""
},
"to": "",
"ttl": {},
"type": "",
"video": {}
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"audio\": {},\n \"contacts\": [\n {\n \"addresses\": [\n {\n \"city\": \"\",\n \"country\": \"\",\n \"country_code\": \"\",\n \"state\": \"\",\n \"street\": \"\",\n \"type\": \"\",\n \"zip\": \"\"\n }\n ],\n \"birthday\": \"\",\n \"emails\": [\n {\n \"email\": \"\",\n \"type\": \"\"\n }\n ],\n \"ims\": [],\n \"name\": {\n \"first_name\": \"\",\n \"formatted_name\": \"\",\n \"last_name\": \"\",\n \"prefix\": \"\",\n \"suffix\": \"\"\n },\n \"org\": {\n \"company\": \"\",\n \"department\": \"\",\n \"title\": \"\"\n },\n \"phones\": [\n {\n \"phone\": \"\",\n \"type\": \"\",\n \"wa_id\": \"\"\n }\n ],\n \"urls\": [\n {\n \"type\": \"\",\n \"url\": \"\"\n }\n ]\n }\n ],\n \"document\": {},\n \"hsm\": {\n \"element_name\": \"\",\n \"language\": {\n \"code\": \"\",\n \"policy\": \"\"\n },\n \"localizable_params\": [\n {\n \"currency\": {\n \"amount_1000\": 0,\n \"currency_code\": \"\"\n },\n \"date_time\": {\n \"component\": {\n \"day_of_month\": 0,\n \"day_of_week\": 0,\n \"hour\": 0,\n \"minute\": 0,\n \"month\": 0,\n \"year\": 0\n },\n \"unix_epoch\": {\n \"timestamp\": 0\n }\n },\n \"default\": \"\"\n }\n ],\n \"namespace\": \"\"\n },\n \"image\": {},\n \"location\": {\n \"address\": \"\",\n \"latitude\": \"\",\n \"longitude\": \"\",\n \"name\": \"\"\n },\n \"preview_url\": false,\n \"recipient_type\": \"\",\n \"text\": {\n \"body\": \"\"\n },\n \"to\": \"\",\n \"ttl\": {},\n \"type\": \"\",\n \"video\": {}\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/messages", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/messages"
payload = {
"audio": {},
"contacts": [
{
"addresses": [
{
"city": "",
"country": "",
"country_code": "",
"state": "",
"street": "",
"type": "",
"zip": ""
}
],
"birthday": "",
"emails": [
{
"email": "",
"type": ""
}
],
"ims": [],
"name": {
"first_name": "",
"formatted_name": "",
"last_name": "",
"prefix": "",
"suffix": ""
},
"org": {
"company": "",
"department": "",
"title": ""
},
"phones": [
{
"phone": "",
"type": "",
"wa_id": ""
}
],
"urls": [
{
"type": "",
"url": ""
}
]
}
],
"document": {},
"hsm": {
"element_name": "",
"language": {
"code": "",
"policy": ""
},
"localizable_params": [
{
"currency": {
"amount_1000": 0,
"currency_code": ""
},
"date_time": {
"component": {
"day_of_month": 0,
"day_of_week": 0,
"hour": 0,
"minute": 0,
"month": 0,
"year": 0
},
"unix_epoch": { "timestamp": 0 }
},
"default": ""
}
],
"namespace": ""
},
"image": {},
"location": {
"address": "",
"latitude": "",
"longitude": "",
"name": ""
},
"preview_url": False,
"recipient_type": "",
"text": { "body": "" },
"to": "",
"ttl": {},
"type": "",
"video": {}
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/messages"
payload <- "{\n \"audio\": {},\n \"contacts\": [\n {\n \"addresses\": [\n {\n \"city\": \"\",\n \"country\": \"\",\n \"country_code\": \"\",\n \"state\": \"\",\n \"street\": \"\",\n \"type\": \"\",\n \"zip\": \"\"\n }\n ],\n \"birthday\": \"\",\n \"emails\": [\n {\n \"email\": \"\",\n \"type\": \"\"\n }\n ],\n \"ims\": [],\n \"name\": {\n \"first_name\": \"\",\n \"formatted_name\": \"\",\n \"last_name\": \"\",\n \"prefix\": \"\",\n \"suffix\": \"\"\n },\n \"org\": {\n \"company\": \"\",\n \"department\": \"\",\n \"title\": \"\"\n },\n \"phones\": [\n {\n \"phone\": \"\",\n \"type\": \"\",\n \"wa_id\": \"\"\n }\n ],\n \"urls\": [\n {\n \"type\": \"\",\n \"url\": \"\"\n }\n ]\n }\n ],\n \"document\": {},\n \"hsm\": {\n \"element_name\": \"\",\n \"language\": {\n \"code\": \"\",\n \"policy\": \"\"\n },\n \"localizable_params\": [\n {\n \"currency\": {\n \"amount_1000\": 0,\n \"currency_code\": \"\"\n },\n \"date_time\": {\n \"component\": {\n \"day_of_month\": 0,\n \"day_of_week\": 0,\n \"hour\": 0,\n \"minute\": 0,\n \"month\": 0,\n \"year\": 0\n },\n \"unix_epoch\": {\n \"timestamp\": 0\n }\n },\n \"default\": \"\"\n }\n ],\n \"namespace\": \"\"\n },\n \"image\": {},\n \"location\": {\n \"address\": \"\",\n \"latitude\": \"\",\n \"longitude\": \"\",\n \"name\": \"\"\n },\n \"preview_url\": false,\n \"recipient_type\": \"\",\n \"text\": {\n \"body\": \"\"\n },\n \"to\": \"\",\n \"ttl\": {},\n \"type\": \"\",\n \"video\": {}\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/messages")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"audio\": {},\n \"contacts\": [\n {\n \"addresses\": [\n {\n \"city\": \"\",\n \"country\": \"\",\n \"country_code\": \"\",\n \"state\": \"\",\n \"street\": \"\",\n \"type\": \"\",\n \"zip\": \"\"\n }\n ],\n \"birthday\": \"\",\n \"emails\": [\n {\n \"email\": \"\",\n \"type\": \"\"\n }\n ],\n \"ims\": [],\n \"name\": {\n \"first_name\": \"\",\n \"formatted_name\": \"\",\n \"last_name\": \"\",\n \"prefix\": \"\",\n \"suffix\": \"\"\n },\n \"org\": {\n \"company\": \"\",\n \"department\": \"\",\n \"title\": \"\"\n },\n \"phones\": [\n {\n \"phone\": \"\",\n \"type\": \"\",\n \"wa_id\": \"\"\n }\n ],\n \"urls\": [\n {\n \"type\": \"\",\n \"url\": \"\"\n }\n ]\n }\n ],\n \"document\": {},\n \"hsm\": {\n \"element_name\": \"\",\n \"language\": {\n \"code\": \"\",\n \"policy\": \"\"\n },\n \"localizable_params\": [\n {\n \"currency\": {\n \"amount_1000\": 0,\n \"currency_code\": \"\"\n },\n \"date_time\": {\n \"component\": {\n \"day_of_month\": 0,\n \"day_of_week\": 0,\n \"hour\": 0,\n \"minute\": 0,\n \"month\": 0,\n \"year\": 0\n },\n \"unix_epoch\": {\n \"timestamp\": 0\n }\n },\n \"default\": \"\"\n }\n ],\n \"namespace\": \"\"\n },\n \"image\": {},\n \"location\": {\n \"address\": \"\",\n \"latitude\": \"\",\n \"longitude\": \"\",\n \"name\": \"\"\n },\n \"preview_url\": false,\n \"recipient_type\": \"\",\n \"text\": {\n \"body\": \"\"\n },\n \"to\": \"\",\n \"ttl\": {},\n \"type\": \"\",\n \"video\": {}\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/messages') do |req|
req.body = "{\n \"audio\": {},\n \"contacts\": [\n {\n \"addresses\": [\n {\n \"city\": \"\",\n \"country\": \"\",\n \"country_code\": \"\",\n \"state\": \"\",\n \"street\": \"\",\n \"type\": \"\",\n \"zip\": \"\"\n }\n ],\n \"birthday\": \"\",\n \"emails\": [\n {\n \"email\": \"\",\n \"type\": \"\"\n }\n ],\n \"ims\": [],\n \"name\": {\n \"first_name\": \"\",\n \"formatted_name\": \"\",\n \"last_name\": \"\",\n \"prefix\": \"\",\n \"suffix\": \"\"\n },\n \"org\": {\n \"company\": \"\",\n \"department\": \"\",\n \"title\": \"\"\n },\n \"phones\": [\n {\n \"phone\": \"\",\n \"type\": \"\",\n \"wa_id\": \"\"\n }\n ],\n \"urls\": [\n {\n \"type\": \"\",\n \"url\": \"\"\n }\n ]\n }\n ],\n \"document\": {},\n \"hsm\": {\n \"element_name\": \"\",\n \"language\": {\n \"code\": \"\",\n \"policy\": \"\"\n },\n \"localizable_params\": [\n {\n \"currency\": {\n \"amount_1000\": 0,\n \"currency_code\": \"\"\n },\n \"date_time\": {\n \"component\": {\n \"day_of_month\": 0,\n \"day_of_week\": 0,\n \"hour\": 0,\n \"minute\": 0,\n \"month\": 0,\n \"year\": 0\n },\n \"unix_epoch\": {\n \"timestamp\": 0\n }\n },\n \"default\": \"\"\n }\n ],\n \"namespace\": \"\"\n },\n \"image\": {},\n \"location\": {\n \"address\": \"\",\n \"latitude\": \"\",\n \"longitude\": \"\",\n \"name\": \"\"\n },\n \"preview_url\": false,\n \"recipient_type\": \"\",\n \"text\": {\n \"body\": \"\"\n },\n \"to\": \"\",\n \"ttl\": {},\n \"type\": \"\",\n \"video\": {}\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/messages";
let payload = json!({
"audio": json!({}),
"contacts": (
json!({
"addresses": (
json!({
"city": "",
"country": "",
"country_code": "",
"state": "",
"street": "",
"type": "",
"zip": ""
})
),
"birthday": "",
"emails": (
json!({
"email": "",
"type": ""
})
),
"ims": (),
"name": json!({
"first_name": "",
"formatted_name": "",
"last_name": "",
"prefix": "",
"suffix": ""
}),
"org": json!({
"company": "",
"department": "",
"title": ""
}),
"phones": (
json!({
"phone": "",
"type": "",
"wa_id": ""
})
),
"urls": (
json!({
"type": "",
"url": ""
})
)
})
),
"document": json!({}),
"hsm": json!({
"element_name": "",
"language": json!({
"code": "",
"policy": ""
}),
"localizable_params": (
json!({
"currency": json!({
"amount_1000": 0,
"currency_code": ""
}),
"date_time": json!({
"component": json!({
"day_of_month": 0,
"day_of_week": 0,
"hour": 0,
"minute": 0,
"month": 0,
"year": 0
}),
"unix_epoch": json!({"timestamp": 0})
}),
"default": ""
})
),
"namespace": ""
}),
"image": json!({}),
"location": json!({
"address": "",
"latitude": "",
"longitude": "",
"name": ""
}),
"preview_url": false,
"recipient_type": "",
"text": json!({"body": ""}),
"to": "",
"ttl": json!({}),
"type": "",
"video": json!({})
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/messages \
--header 'content-type: application/json' \
--data '{
"audio": {},
"contacts": [
{
"addresses": [
{
"city": "",
"country": "",
"country_code": "",
"state": "",
"street": "",
"type": "",
"zip": ""
}
],
"birthday": "",
"emails": [
{
"email": "",
"type": ""
}
],
"ims": [],
"name": {
"first_name": "",
"formatted_name": "",
"last_name": "",
"prefix": "",
"suffix": ""
},
"org": {
"company": "",
"department": "",
"title": ""
},
"phones": [
{
"phone": "",
"type": "",
"wa_id": ""
}
],
"urls": [
{
"type": "",
"url": ""
}
]
}
],
"document": {},
"hsm": {
"element_name": "",
"language": {
"code": "",
"policy": ""
},
"localizable_params": [
{
"currency": {
"amount_1000": 0,
"currency_code": ""
},
"date_time": {
"component": {
"day_of_month": 0,
"day_of_week": 0,
"hour": 0,
"minute": 0,
"month": 0,
"year": 0
},
"unix_epoch": {
"timestamp": 0
}
},
"default": ""
}
],
"namespace": ""
},
"image": {},
"location": {
"address": "",
"latitude": "",
"longitude": "",
"name": ""
},
"preview_url": false,
"recipient_type": "",
"text": {
"body": ""
},
"to": "",
"ttl": {},
"type": "",
"video": {}
}'echo '{
"audio": {},
"contacts": [
{
"addresses": [
{
"city": "",
"country": "",
"country_code": "",
"state": "",
"street": "",
"type": "",
"zip": ""
}
],
"birthday": "",
"emails": [
{
"email": "",
"type": ""
}
],
"ims": [],
"name": {
"first_name": "",
"formatted_name": "",
"last_name": "",
"prefix": "",
"suffix": ""
},
"org": {
"company": "",
"department": "",
"title": ""
},
"phones": [
{
"phone": "",
"type": "",
"wa_id": ""
}
],
"urls": [
{
"type": "",
"url": ""
}
]
}
],
"document": {},
"hsm": {
"element_name": "",
"language": {
"code": "",
"policy": ""
},
"localizable_params": [
{
"currency": {
"amount_1000": 0,
"currency_code": ""
},
"date_time": {
"component": {
"day_of_month": 0,
"day_of_week": 0,
"hour": 0,
"minute": 0,
"month": 0,
"year": 0
},
"unix_epoch": {
"timestamp": 0
}
},
"default": ""
}
],
"namespace": ""
},
"image": {},
"location": {
"address": "",
"latitude": "",
"longitude": "",
"name": ""
},
"preview_url": false,
"recipient_type": "",
"text": {
"body": ""
},
"to": "",
"ttl": {},
"type": "",
"video": {}
}' | \
http POST {{baseUrl}}/messages \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "audio": {},\n "contacts": [\n {\n "addresses": [\n {\n "city": "",\n "country": "",\n "country_code": "",\n "state": "",\n "street": "",\n "type": "",\n "zip": ""\n }\n ],\n "birthday": "",\n "emails": [\n {\n "email": "",\n "type": ""\n }\n ],\n "ims": [],\n "name": {\n "first_name": "",\n "formatted_name": "",\n "last_name": "",\n "prefix": "",\n "suffix": ""\n },\n "org": {\n "company": "",\n "department": "",\n "title": ""\n },\n "phones": [\n {\n "phone": "",\n "type": "",\n "wa_id": ""\n }\n ],\n "urls": [\n {\n "type": "",\n "url": ""\n }\n ]\n }\n ],\n "document": {},\n "hsm": {\n "element_name": "",\n "language": {\n "code": "",\n "policy": ""\n },\n "localizable_params": [\n {\n "currency": {\n "amount_1000": 0,\n "currency_code": ""\n },\n "date_time": {\n "component": {\n "day_of_month": 0,\n "day_of_week": 0,\n "hour": 0,\n "minute": 0,\n "month": 0,\n "year": 0\n },\n "unix_epoch": {\n "timestamp": 0\n }\n },\n "default": ""\n }\n ],\n "namespace": ""\n },\n "image": {},\n "location": {\n "address": "",\n "latitude": "",\n "longitude": "",\n "name": ""\n },\n "preview_url": false,\n "recipient_type": "",\n "text": {\n "body": ""\n },\n "to": "",\n "ttl": {},\n "type": "",\n "video": {}\n}' \
--output-document \
- {{baseUrl}}/messagesimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"audio": [],
"contacts": [
[
"addresses": [
[
"city": "",
"country": "",
"country_code": "",
"state": "",
"street": "",
"type": "",
"zip": ""
]
],
"birthday": "",
"emails": [
[
"email": "",
"type": ""
]
],
"ims": [],
"name": [
"first_name": "",
"formatted_name": "",
"last_name": "",
"prefix": "",
"suffix": ""
],
"org": [
"company": "",
"department": "",
"title": ""
],
"phones": [
[
"phone": "",
"type": "",
"wa_id": ""
]
],
"urls": [
[
"type": "",
"url": ""
]
]
]
],
"document": [],
"hsm": [
"element_name": "",
"language": [
"code": "",
"policy": ""
],
"localizable_params": [
[
"currency": [
"amount_1000": 0,
"currency_code": ""
],
"date_time": [
"component": [
"day_of_month": 0,
"day_of_week": 0,
"hour": 0,
"minute": 0,
"month": 0,
"year": 0
],
"unix_epoch": ["timestamp": 0]
],
"default": ""
]
],
"namespace": ""
],
"image": [],
"location": [
"address": "",
"latitude": "",
"longitude": "",
"name": ""
],
"preview_url": false,
"recipient_type": "",
"text": ["body": ""],
"to": "",
"ttl": [],
"type": "",
"video": []
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messages")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"messages": [
{
"id": "gBEGkYiEB1VXAglK1ZEqA1YKPrU"
}
]
}
GET
Get-Profile-About
{{baseUrl}}/settings/profile/about
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/settings/profile/about");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/settings/profile/about")require "http/client"
url = "{{baseUrl}}/settings/profile/about"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/settings/profile/about"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/settings/profile/about");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/settings/profile/about"
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/settings/profile/about HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/settings/profile/about")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/settings/profile/about"))
.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}}/settings/profile/about")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/settings/profile/about")
.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}}/settings/profile/about');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/settings/profile/about'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/settings/profile/about';
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}}/settings/profile/about',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/settings/profile/about")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/settings/profile/about',
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}}/settings/profile/about'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/settings/profile/about');
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}}/settings/profile/about'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/settings/profile/about';
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}}/settings/profile/about"]
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}}/settings/profile/about" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/settings/profile/about",
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}}/settings/profile/about');
echo $response->getBody();setUrl('{{baseUrl}}/settings/profile/about');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/settings/profile/about');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/settings/profile/about' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/settings/profile/about' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/settings/profile/about")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/settings/profile/about"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/settings/profile/about"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/settings/profile/about")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/settings/profile/about') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/settings/profile/about";
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}}/settings/profile/abouthttp GET {{baseUrl}}/settings/profile/aboutwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/settings/profile/aboutimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/settings/profile/about")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"settings": {
"profile": {
"about": {
"text": "your-profile-about-text"
}
}
}
}
GET
Get-Profile-Photo
{{baseUrl}}/settings/profile/photo
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/settings/profile/photo");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/settings/profile/photo")require "http/client"
url = "{{baseUrl}}/settings/profile/photo"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/settings/profile/photo"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/settings/profile/photo");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/settings/profile/photo"
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/settings/profile/photo HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/settings/profile/photo")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/settings/profile/photo"))
.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}}/settings/profile/photo")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/settings/profile/photo")
.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}}/settings/profile/photo');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/settings/profile/photo'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/settings/profile/photo';
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}}/settings/profile/photo',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/settings/profile/photo")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/settings/profile/photo',
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}}/settings/profile/photo'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/settings/profile/photo');
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}}/settings/profile/photo'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/settings/profile/photo';
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}}/settings/profile/photo"]
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}}/settings/profile/photo" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/settings/profile/photo",
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}}/settings/profile/photo');
echo $response->getBody();setUrl('{{baseUrl}}/settings/profile/photo');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/settings/profile/photo');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/settings/profile/photo' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/settings/profile/photo' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/settings/profile/photo")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/settings/profile/photo"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/settings/profile/photo"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/settings/profile/photo")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/settings/profile/photo') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/settings/profile/photo";
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}}/settings/profile/photohttp GET {{baseUrl}}/settings/profile/photowget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/settings/profile/photoimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/settings/profile/photo")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"settings": {
"profile": {
"photo": {
"link": "profile-photo-url"
}
}
}
}
PATCH
Update-Profile-About
{{baseUrl}}/settings/profile/about
BODY json
{
"text": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/settings/profile/about");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"text\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd); (require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/settings/profile/about" {:content-type :json
:form-params {:text ""}}) require "http/client"
url = "{{baseUrl}}/settings/profile/about"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"text\": \"\"\n}"
response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/settings/profile/about"),
Content = new StringContent("{\n \"text\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
} var client = new RestClient("{{baseUrl}}/settings/profile/about");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"text\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request); package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/settings/profile/about"
payload := strings.NewReader("{\n \"text\": \"\"\n}")
req, _ := http.NewRequest("PATCH", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
} PATCH /baseUrl/settings/profile/about HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 31
{
"text": ""
} AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/settings/profile/about")
.setHeader("content-type", "application/json")
.setBody("{\n \"text\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close(); HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/settings/profile/about"))
.header("content-type", "application/json")
.method("PATCH", HttpRequest.BodyPublishers.ofString("{\n \"text\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"text\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/settings/profile/about")
.patch(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute(); HttpResponse response = Unirest.patch("{{baseUrl}}/settings/profile/about")
.header("content-type", "application/json")
.body("{\n \"text\": \"\"\n}")
.asString(); const data = JSON.stringify({
text: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/settings/profile/about');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data); import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/settings/profile/about',
headers: {'content-type': 'application/json'},
data: {text: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
} const url = '{{baseUrl}}/settings/profile/about';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"text":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
} const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/settings/profile/about',
method: 'PATCH',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "text": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
}); val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"text\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/settings/profile/about")
.patch(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute() const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/settings/profile/about',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({text: ''}));
req.end(); const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/settings/profile/about',
headers: {'content-type': 'application/json'},
body: {text: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
}); const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/settings/profile/about');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
text: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
}); const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/settings/profile/about',
headers: {'content-type': 'application/json'},
data: {text: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
} const fetch = require('node-fetch');
const url = '{{baseUrl}}/settings/profile/about';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"text":""}'
};
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/json" };
NSDictionary *parameters = @{ @"text": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/settings/profile/about"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/settings/profile/about" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"text\": \"\"\n}" in
Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/settings/profile/about",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
CURLOPT_POSTFIELDS => json_encode([
'text' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
} request('PATCH', '{{baseUrl}}/settings/profile/about', [
'body' => '{
"text": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody(); setUrl('{{baseUrl}}/settings/profile/about');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'text' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
} append(json_encode([
'text' => ''
]));
$request->setRequestUrl('{{baseUrl}}/settings/profile/about');
$request->setRequestMethod('PATCH');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody(); $headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/settings/profile/about' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"text": ""
}' $headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/settings/profile/about' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"text": ""
}' import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"text\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PATCH", "/baseUrl/settings/profile/about", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8")) import requests
url = "{{baseUrl}}/settings/profile/about"
payload = { "text": "" }
headers = {"content-type": "application/json"}
response = requests.patch(url, json=payload, headers=headers)
print(response.json()) library(httr)
url <- "{{baseUrl}}/settings/profile/about"
payload <- "{\n \"text\": \"\"\n}"
encode <- "json"
response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text") require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/settings/profile/about")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"text\": \"\"\n}"
response = http.request(request)
puts response.read_body require 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.patch('/baseUrl/settings/profile/about') do |req|
req.body = "{\n \"text\": \"\"\n}"
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}}/settings/profile/about";
let payload = json!({"text": ""});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/settings/profile/about \
--header 'content-type: application/json' \
--data '{
"text": ""
}' echo '{
"text": ""
}' | \
http PATCH {{baseUrl}}/settings/profile/about \
content-type:application/json wget --quiet \
--method PATCH \
--header 'content-type: application/json' \
--body-data '{\n "text": ""\n}' \
--output-document \
- {{baseUrl}}/settings/profile/about import Foundation
let headers = ["content-type": "application/json"]
let parameters = ["text": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/settings/profile/about")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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
Update-Profile-Photo
{{baseUrl}}/settings/profile/photo
BODY multipartForm
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/settings/profile/photo");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/settings/profile/photo" {:multipart [{:name "File"
:content ""}]})require "http/client"
url = "{{baseUrl}}/settings/profile/photo"
headers = HTTP::Headers{
"content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/settings/profile/photo"),
Content = new MultipartFormDataContent
{
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "File",
}
}
},
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/settings/profile/photo");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/settings/profile/photo"
payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/settings/profile/photo HTTP/1.1
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 113
-----011000010111000001101001
Content-Disposition: form-data; name="File"
-----011000010111000001101001--
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/settings/profile/photo")
.setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
.setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/settings/profile/photo"))
.header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
.method("POST", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
.url("{{baseUrl}}/settings/profile/photo")
.post(body)
.addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/settings/profile/photo")
.header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
.body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
.asString(); const data = new FormData();
data.append('File', '');
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/settings/profile/photo');
xhr.send(data);import axios from 'axios';
const form = new FormData();
form.append('File', '');
const options = {
method: 'POST',
url: '{{baseUrl}}/settings/profile/photo',
headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
data: '[form]'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/settings/profile/photo';
const form = new FormData();
form.append('File', '');
const options = {method: 'POST'};
options.body = form;
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const form = new FormData();
form.append('File', '');
const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/settings/profile/photo',
method: 'POST',
headers: {},
processData: false,
contentType: false,
mimeType: 'multipart/form-data',
data: form
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
.url("{{baseUrl}}/settings/profile/photo")
.post(body)
.addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/settings/profile/photo',
headers: {
'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
}
};
const req = http.request(options, function (res) {
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('-----011000010111000001101001\r\nContent-Disposition: form-data; name="File"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/settings/profile/photo',
headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
formData: {File: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/settings/profile/photo');
req.headers({
'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});
req.multipart([]);
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}}/settings/profile/photo',
headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="File"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const FormData = require('form-data');
const fetch = require('node-fetch');
const formData = new FormData();
formData.append('File', '');
const url = '{{baseUrl}}/settings/profile/photo';
const options = {method: 'POST'};
options.body = formData;
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": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"File", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";
NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
[body appendFormat:@"--%@\r\n", boundary];
if (param[@"fileName"]) {
[body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
[body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
[body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
if (error) {
NSLog(@"%@", error);
}
} else {
[body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
[body appendFormat:@"%@", param[@"value"]];
}
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/settings/profile/photo"]
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}}/settings/profile/photo" in
let headers = Header.add (Header.init ()) "content-type" "multipart/form-data; boundary=---011000010111000001101001" in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/settings/profile/photo",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
CURLOPT_HTTPHEADER => [
"content-type: multipart/form-data; boundary=---011000010111000001101001"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/settings/profile/photo', [
'headers' => [
'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/settings/profile/photo');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);
$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="File"
-----011000010111000001101001--
');
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}addForm(null, null);
$request->setRequestUrl('{{baseUrl}}/settings/profile/photo');
$request->setRequestMethod('POST');
$request->setBody($body);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/settings/profile/photo' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="File"
-----011000010111000001101001--
'$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/settings/profile/photo' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="File"
-----011000010111000001101001--
'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = { 'content-type': "multipart/form-data; boundary=---011000010111000001101001" }
conn.request("POST", "/baseUrl/settings/profile/photo", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/settings/profile/photo"
payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {"content-type": "multipart/form-data; boundary=---011000010111000001101001"}
response = requests.post(url, data=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/settings/profile/photo"
payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
encode <- "multipart"
response <- VERB("POST", url, body = payload, content_type("multipart/form-data"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/settings/profile/photo")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)
response = conn.post('/baseUrl/settings/profile/photo') do |req|
req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"File\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/settings/profile/photo";
let form = reqwest::multipart::Form::new()
.text("File", "");
let mut headers = reqwest::header::HeaderMap::new();
let client = reqwest::Client::new();
let response = client.post(url)
.multipart(form)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/settings/profile/photo \
--header 'content-type: multipart/form-data' \
--form File=echo '-----011000010111000001101001
Content-Disposition: form-data; name="File"
-----011000010111000001101001--
' | \
http POST {{baseUrl}}/settings/profile/photo \
content-type:'multipart/form-data; boundary=---011000010111000001101001'wget --quiet \
--method POST \
--header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
--body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="File"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
--output-document \
- {{baseUrl}}/settings/profile/photoimport Foundation
let headers = ["content-type": "multipart/form-data; boundary=---011000010111000001101001"]
let parameters = [
[
"name": "File",
"value": ""
]
]
let boundary = "---011000010111000001101001"
var body = ""
var error: NSError? = nil
for param in parameters {
let paramName = param["name"]!
body += "--\(boundary)\r\n"
body += "Content-Disposition:form-data; name=\"\(paramName)\""
if let filename = param["fileName"] {
let contentType = param["content-type"]!
let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
if (error != nil) {
print(error as Any)
}
body += "; filename=\"\(filename)\"\r\n"
body += "Content-Type: \(contentType)\r\n\r\n"
body += fileContent
} else if let paramValue = param["value"] {
body += "\r\n\r\n\(paramValue)"
}
}
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/settings/profile/photo")! 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
Register-Account
{{baseUrl}}/account/verify
BODY json
{
"code": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account/verify");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"code\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd); (require '[clj-http.client :as client])
(client/post "{{baseUrl}}/account/verify" {:content-type :json
:form-params {:code ""}}) require "http/client"
url = "{{baseUrl}}/account/verify"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"code\": \"\"\n}"
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}}/account/verify"),
Content = new StringContent("{\n \"code\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
} var client = new RestClient("{{baseUrl}}/account/verify");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"code\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request); package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/account/verify"
payload := strings.NewReader("{\n \"code\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
} POST /baseUrl/account/verify HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 58
{
"code": ""
} AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account/verify")
.setHeader("content-type", "application/json")
.setBody("{\n \"code\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close(); HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/account/verify"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"code\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"code\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/account/verify")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute(); HttpResponse response = Unirest.post("{{baseUrl}}/account/verify")
.header("content-type", "application/json")
.body("{\n \"code\": \"\"\n}")
.asString(); const data = JSON.stringify({
code: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/account/verify');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data); import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/account/verify',
headers: {'content-type': 'application/json'},
data: {code: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
} const url = '{{baseUrl}}/account/verify';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"code":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
} const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/account/verify',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "code": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
}); val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"code\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/account/verify")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute() const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/account/verify',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({code: ''}));
req.end(); const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/account/verify',
headers: {'content-type': 'application/json'},
body: {code: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
}); const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/account/verify');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
code: ''
});
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}}/account/verify',
headers: {'content-type': 'application/json'},
data: {code: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
} const fetch = require('node-fetch');
const url = '{{baseUrl}}/account/verify';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"code":""}'
};
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/json" };
NSDictionary *parameters = @{ @"code": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account/verify"]
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}}/account/verify" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"code\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/account/verify",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'code' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
} request('POST', '{{baseUrl}}/account/verify', [
'body' => '{
"code": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody(); setUrl('{{baseUrl}}/account/verify');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'code' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
} append(json_encode([
'code' => ''
]));
$request->setRequestUrl('{{baseUrl}}/account/verify');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody(); $headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account/verify' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"code": ""
}' $headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account/verify' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"code": ""
}' import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"code\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/account/verify", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8")) import requests
url = "{{baseUrl}}/account/verify"
payload = { "code": "" }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json()) library(httr)
url <- "{{baseUrl}}/account/verify"
payload <- "{\n \"code\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text") require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/account/verify")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"code\": \"\"\n}"
response = http.request(request)
puts response.read_body require 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/account/verify') do |req|
req.body = "{\n \"code\": \"\"\n}"
end
puts response.status
puts response.body use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/account/verify";
let payload = json!({"code": ""});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/account/verify \
--header 'content-type: application/json' \
--data '{
"code": ""
}' echo '{
"code": ""
}' | \
http POST {{baseUrl}}/account/verify \
content-type:application/json wget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "code": ""\n}' \
--output-document \
- {{baseUrl}}/account/verify import Foundation
let headers = ["content-type": "application/json"]
let parameters = ["code": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account/verify")! 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
Request-Code
{{baseUrl}}/account
BODY json
{
"cc": "",
"cert": "",
"method": "",
"phone_number": "",
"pin": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"cc\": \"\",\n \"cert\": \"\",\n \"method\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/account" {:content-type :json
:form-params {:cc ""
:cert ""
:method ""
:phone_number ""
:pin ""}})require "http/client"
url = "{{baseUrl}}/account"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"cc\": \"\",\n \"cert\": \"\",\n \"method\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/account"),
Content = new StringContent("{\n \"cc\": \"\",\n \"cert\": \"\",\n \"method\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/account");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"cc\": \"\",\n \"cert\": \"\",\n \"method\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/account"
payload := strings.NewReader("{\n \"cc\": \"\",\n \"cert\": \"\",\n \"method\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/account HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 79
{
"cc": "",
"cert": "",
"method": "",
"phone_number": "",
"pin": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/account")
.setHeader("content-type", "application/json")
.setBody("{\n \"cc\": \"\",\n \"cert\": \"\",\n \"method\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/account"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"cc\": \"\",\n \"cert\": \"\",\n \"method\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"cc\": \"\",\n \"cert\": \"\",\n \"method\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/account")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/account")
.header("content-type", "application/json")
.body("{\n \"cc\": \"\",\n \"cert\": \"\",\n \"method\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\"\n}")
.asString(); const data = JSON.stringify({
cc: '',
cert: '',
method: '',
phone_number: '',
pin: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/account');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/account',
headers: {'content-type': 'application/json'},
data: {cc: '', cert: '', method: '', phone_number: '', pin: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/account';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"cc":"","cert":"","method":"","phone_number":"","pin":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/account',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "cc": "",\n "cert": "",\n "method": "",\n "phone_number": "",\n "pin": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"cc\": \"\",\n \"cert\": \"\",\n \"method\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/account")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/account',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({cc: '', cert: '', method: '', phone_number: '', pin: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/account',
headers: {'content-type': 'application/json'},
body: {cc: '', cert: '', method: '', phone_number: '', pin: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/account');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
cc: '',
cert: '',
method: '',
phone_number: '',
pin: ''
});
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}}/account',
headers: {'content-type': 'application/json'},
data: {cc: '', cert: '', method: '', phone_number: '', pin: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/account';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"cc":"","cert":"","method":"","phone_number":"","pin":""}'
};
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/json" };
NSDictionary *parameters = @{ @"cc": @"",
@"cert": @"",
@"method": @"",
@"phone_number": @"",
@"pin": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account"]
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}}/account" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"cc\": \"\",\n \"cert\": \"\",\n \"method\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/account",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'cc' => '',
'cert' => '',
'method' => '',
'phone_number' => '',
'pin' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/account', [
'body' => '{
"cc": "",
"cert": "",
"method": "",
"phone_number": "",
"pin": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/account');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'cc' => '',
'cert' => '',
'method' => '',
'phone_number' => '',
'pin' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'cc' => '',
'cert' => '',
'method' => '',
'phone_number' => '',
'pin' => ''
]));
$request->setRequestUrl('{{baseUrl}}/account');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"cc": "",
"cert": "",
"method": "",
"phone_number": "",
"pin": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"cc": "",
"cert": "",
"method": "",
"phone_number": "",
"pin": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"cc\": \"\",\n \"cert\": \"\",\n \"method\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/account", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/account"
payload = {
"cc": "",
"cert": "",
"method": "",
"phone_number": "",
"pin": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/account"
payload <- "{\n \"cc\": \"\",\n \"cert\": \"\",\n \"method\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/account")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"cc\": \"\",\n \"cert\": \"\",\n \"method\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/account') do |req|
req.body = "{\n \"cc\": \"\",\n \"cert\": \"\",\n \"method\": \"\",\n \"phone_number\": \"\",\n \"pin\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/account";
let payload = json!({
"cc": "",
"cert": "",
"method": "",
"phone_number": "",
"pin": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/account \
--header 'content-type: application/json' \
--data '{
"cc": "",
"cert": "",
"method": "",
"phone_number": "",
"pin": ""
}'echo '{
"cc": "",
"cert": "",
"method": "",
"phone_number": "",
"pin": ""
}' | \
http POST {{baseUrl}}/account \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "cc": "",\n "cert": "",\n "method": "",\n "phone_number": "",\n "pin": ""\n}' \
--output-document \
- {{baseUrl}}/accountimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"cc": "",
"cert": "",
"method": "",
"phone_number": "",
"pin": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"account": [
{
"vname": "decoded-vname-from-cert"
}
]
}
DELETE
Disable-Two-Step
{{baseUrl}}/settings/account/two-step
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/settings/account/two-step");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/settings/account/two-step")require "http/client"
url = "{{baseUrl}}/settings/account/two-step"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/settings/account/two-step"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/settings/account/two-step");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/settings/account/two-step"
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/settings/account/two-step HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/settings/account/two-step")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/settings/account/two-step"))
.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}}/settings/account/two-step")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/settings/account/two-step")
.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}}/settings/account/two-step');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/settings/account/two-step'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/settings/account/two-step';
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}}/settings/account/two-step',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/settings/account/two-step")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/settings/account/two-step',
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}}/settings/account/two-step'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/settings/account/two-step');
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}}/settings/account/two-step'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/settings/account/two-step';
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}}/settings/account/two-step"]
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}}/settings/account/two-step" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/settings/account/two-step",
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}}/settings/account/two-step');
echo $response->getBody();setUrl('{{baseUrl}}/settings/account/two-step');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/settings/account/two-step');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/settings/account/two-step' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/settings/account/two-step' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/settings/account/two-step")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/settings/account/two-step"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/settings/account/two-step"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/settings/account/two-step")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/settings/account/two-step') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/settings/account/two-step";
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}}/settings/account/two-stephttp DELETE {{baseUrl}}/settings/account/two-stepwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/settings/account/two-stepimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/settings/account/two-step")! 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()
POST
Enable-Two-Step
{{baseUrl}}/settings/account/two-step
BODY json
{
"pin": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/settings/account/two-step");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"pin\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd); (require '[clj-http.client :as client])
(client/post "{{baseUrl}}/settings/account/two-step" {:content-type :json
:form-params {:pin ""}}) require "http/client"
url = "{{baseUrl}}/settings/account/two-step"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"pin\": \"\"\n}"
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}}/settings/account/two-step"),
Content = new StringContent("{\n \"pin\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
} var client = new RestClient("{{baseUrl}}/settings/account/two-step");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"pin\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request); package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/settings/account/two-step"
payload := strings.NewReader("{\n \"pin\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
} POST /baseUrl/settings/account/two-step HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 42
{
"pin": ""
} AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/settings/account/two-step")
.setHeader("content-type", "application/json")
.setBody("{\n \"pin\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close(); HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/settings/account/two-step"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"pin\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"pin\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/settings/account/two-step")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute(); HttpResponse response = Unirest.post("{{baseUrl}}/settings/account/two-step")
.header("content-type", "application/json")
.body("{\n \"pin\": \"\"\n}")
.asString(); const data = JSON.stringify({
pin: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/settings/account/two-step');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data); import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/settings/account/two-step',
headers: {'content-type': 'application/json'},
data: {pin: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
} const url = '{{baseUrl}}/settings/account/two-step';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"pin":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
} const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/settings/account/two-step',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "pin": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
}); val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"pin\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/settings/account/two-step")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute() const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/settings/account/two-step',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({pin: ''}));
req.end(); const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/settings/account/two-step',
headers: {'content-type': 'application/json'},
body: {pin: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
}); const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/settings/account/two-step');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
pin: ''
});
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}}/settings/account/two-step',
headers: {'content-type': 'application/json'},
data: {pin: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
} const fetch = require('node-fetch');
const url = '{{baseUrl}}/settings/account/two-step';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"pin":""}'
};
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/json" };
NSDictionary *parameters = @{ @"pin": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/settings/account/two-step"]
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}}/settings/account/two-step" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"pin\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/settings/account/two-step",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'pin' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
} request('POST', '{{baseUrl}}/settings/account/two-step', [
'body' => '{
"pin": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody(); setUrl('{{baseUrl}}/settings/account/two-step');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'pin' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
} append(json_encode([
'pin' => ''
]));
$request->setRequestUrl('{{baseUrl}}/settings/account/two-step');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody(); $headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/settings/account/two-step' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"pin": ""
}' $headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/settings/account/two-step' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"pin": ""
}' import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"pin\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/settings/account/two-step", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8")) import requests
url = "{{baseUrl}}/settings/account/two-step"
payload = { "pin": "" }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json()) library(httr)
url <- "{{baseUrl}}/settings/account/two-step"
payload <- "{\n \"pin\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text") require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/settings/account/two-step")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"pin\": \"\"\n}"
response = http.request(request)
puts response.read_body require 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/settings/account/two-step') do |req|
req.body = "{\n \"pin\": \"\"\n}"
end
puts response.status
puts response.body use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/settings/account/two-step";
let payload = json!({"pin": ""});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/settings/account/two-step \
--header 'content-type: application/json' \
--data '{
"pin": ""
}' echo '{
"pin": ""
}' | \
http POST {{baseUrl}}/settings/account/two-step \
content-type:application/json wget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "pin": ""\n}' \
--output-document \
- {{baseUrl}}/settings/account/two-step import Foundation
let headers = ["content-type": "application/json"]
let parameters = ["pin": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/settings/account/two-step")! 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-User
{{baseUrl}}/users
BODY json
{
"password": "",
"username": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"password\": \"\",\n \"username\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/users" {:content-type :json
:form-params {:password ""
:username ""}})require "http/client"
url = "{{baseUrl}}/users"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"password\": \"\",\n \"username\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/users"),
Content = new StringContent("{\n \"password\": \"\",\n \"username\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"password\": \"\",\n \"username\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users"
payload := strings.NewReader("{\n \"password\": \"\",\n \"username\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/users HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 38
{
"password": "",
"username": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/users")
.setHeader("content-type", "application/json")
.setBody("{\n \"password\": \"\",\n \"username\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"password\": \"\",\n \"username\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"password\": \"\",\n \"username\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/users")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/users")
.header("content-type", "application/json")
.body("{\n \"password\": \"\",\n \"username\": \"\"\n}")
.asString(); const data = JSON.stringify({
password: '',
username: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/users');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/users',
headers: {'content-type': 'application/json'},
data: {password: '', username: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"password":"","username":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/users',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "password": "",\n "username": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"password\": \"\",\n \"username\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/users")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/users',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({password: '', username: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/users',
headers: {'content-type': 'application/json'},
body: {password: '', username: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/users');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
password: '',
username: ''
});
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}}/users',
headers: {'content-type': 'application/json'},
data: {password: '', username: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"password":"","username":""}'
};
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/json" };
NSDictionary *parameters = @{ @"password": @"",
@"username": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/users" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"password\": \"\",\n \"username\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'password' => '',
'username' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/users', [
'body' => '{
"password": "",
"username": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/users');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'password' => '',
'username' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'password' => '',
'username' => ''
]));
$request->setRequestUrl('{{baseUrl}}/users');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"password": "",
"username": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"password": "",
"username": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"password\": \"\",\n \"username\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/users", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users"
payload = {
"password": "",
"username": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/users"
payload <- "{\n \"password\": \"\",\n \"username\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"password\": \"\",\n \"username\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/users') do |req|
req.body = "{\n \"password\": \"\",\n \"username\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users";
let payload = json!({
"password": "",
"username": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/users \
--header 'content-type: application/json' \
--data '{
"password": "",
"username": ""
}'echo '{
"password": "",
"username": ""
}' | \
http POST {{baseUrl}}/users \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "password": "",\n "username": ""\n}' \
--output-document \
- {{baseUrl}}/usersimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"password": "",
"username": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"users": [
{
"username": "username"
}
]
}
DELETE
Delete-User
{{baseUrl}}/users/:UserUsername
QUERY PARAMS
UserUsername
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:UserUsername");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/users/:UserUsername")require "http/client"
url = "{{baseUrl}}/users/:UserUsername"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/users/:UserUsername"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/:UserUsername");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/:UserUsername"
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/users/:UserUsername HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/users/:UserUsername")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/:UserUsername"))
.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}}/users/:UserUsername")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/users/:UserUsername")
.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}}/users/:UserUsername');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/users/:UserUsername'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/:UserUsername';
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}}/users/:UserUsername',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/users/:UserUsername")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/:UserUsername',
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}}/users/:UserUsername'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/users/:UserUsername');
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}}/users/:UserUsername'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/:UserUsername';
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}}/users/:UserUsername"]
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}}/users/:UserUsername" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/:UserUsername",
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}}/users/:UserUsername');
echo $response->getBody();setUrl('{{baseUrl}}/users/:UserUsername');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/users/:UserUsername');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:UserUsername' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:UserUsername' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/users/:UserUsername")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/:UserUsername"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/:UserUsername"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/:UserUsername")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/users/:UserUsername') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/:UserUsername";
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}}/users/:UserUsernamehttp DELETE {{baseUrl}}/users/:UserUsernamewget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/users/:UserUsernameimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:UserUsername")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"users": [
{
"username": "username"
}
]
}
GET
Get-User
{{baseUrl}}/users/:UserUsername
QUERY PARAMS
UserUsername
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:UserUsername");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/users/:UserUsername")require "http/client"
url = "{{baseUrl}}/users/:UserUsername"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/users/:UserUsername"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/:UserUsername");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/:UserUsername"
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/users/:UserUsername HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/users/:UserUsername")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/:UserUsername"))
.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}}/users/:UserUsername")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/users/:UserUsername")
.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}}/users/:UserUsername');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/users/:UserUsername'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/:UserUsername';
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}}/users/:UserUsername',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/users/:UserUsername")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/:UserUsername',
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}}/users/:UserUsername'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/users/:UserUsername');
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}}/users/:UserUsername'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/:UserUsername';
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}}/users/:UserUsername"]
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}}/users/:UserUsername" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/:UserUsername",
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}}/users/:UserUsername');
echo $response->getBody();setUrl('{{baseUrl}}/users/:UserUsername');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/users/:UserUsername');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:UserUsername' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:UserUsername' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/users/:UserUsername")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/:UserUsername"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/:UserUsername"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/:UserUsername")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/users/:UserUsername') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/:UserUsername";
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}}/users/:UserUsernamehttp GET {{baseUrl}}/users/:UserUsernamewget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/users/:UserUsernameimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:UserUsername")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"users": [
{
"ROLES": "ROLE_USER",
"username": "username"
}
]
}
POST
Login-User
{{baseUrl}}/users/login
BODY json
{
"new_password": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/login");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"new_password\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/users/login" {:content-type :json
:form-params {:new_password ""}})require "http/client"
url = "{{baseUrl}}/users/login"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"new_password\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/users/login"),
Content = new StringContent("{\n \"new_password\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/login");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"new_password\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/login"
payload := strings.NewReader("{\n \"new_password\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/users/login HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 24
{
"new_password": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/users/login")
.setHeader("content-type", "application/json")
.setBody("{\n \"new_password\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/login"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"new_password\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"new_password\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/users/login")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/users/login")
.header("content-type", "application/json")
.body("{\n \"new_password\": \"\"\n}")
.asString(); const data = JSON.stringify({
new_password: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/users/login');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/users/login',
headers: {'content-type': 'application/json'},
data: {new_password: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/login';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"new_password":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/users/login',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "new_password": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"new_password\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/users/login")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/login',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({new_password: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/users/login',
headers: {'content-type': 'application/json'},
body: {new_password: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/users/login');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
new_password: ''
});
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}}/users/login',
headers: {'content-type': 'application/json'},
data: {new_password: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/login';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"new_password":""}'
};
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/json" };
NSDictionary *parameters = @{ @"new_password": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users/login"]
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}}/users/login" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"new_password\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/login",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'new_password' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/users/login', [
'body' => '{
"new_password": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/users/login');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'new_password' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'new_password' => ''
]));
$request->setRequestUrl('{{baseUrl}}/users/login');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/login' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"new_password": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users/login' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"new_password": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"new_password\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/users/login", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/login"
payload = { "new_password": "" }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/login"
payload <- "{\n \"new_password\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/login")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"new_password\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/users/login') do |req|
req.body = "{\n \"new_password\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/login";
let payload = json!({"new_password": ""});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/users/login \
--header 'content-type: application/json' \
--data '{
"new_password": ""
}'echo '{
"new_password": ""
}' | \
http POST {{baseUrl}}/users/login \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "new_password": ""\n}' \
--output-document \
- {{baseUrl}}/users/loginimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["new_password": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/login")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"users": [
{
"expires_after": "2018-03-01 15:29:26+00:00",
"token": "eyJhbGciOHlXVCJ9.eyJ1c2VyIjoNTIzMDE2Nn0.mEoF0COaO00Z1cANo"
}
]
}
POST
Logout-User
{{baseUrl}}/users/logout
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/logout");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/users/logout")require "http/client"
url = "{{baseUrl}}/users/logout"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/users/logout"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/logout");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/logout"
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/users/logout HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/users/logout")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/logout"))
.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}}/users/logout")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/users/logout")
.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}}/users/logout');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/users/logout'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/logout';
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}}/users/logout',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/users/logout")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/logout',
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}}/users/logout'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/users/logout');
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}}/users/logout'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/logout';
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}}/users/logout"]
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}}/users/logout" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/logout",
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}}/users/logout');
echo $response->getBody();setUrl('{{baseUrl}}/users/logout');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/users/logout');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/logout' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/users/logout' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/users/logout")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/logout"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/logout"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/logout")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/users/logout') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/logout";
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}}/users/logouthttp POST {{baseUrl}}/users/logoutwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/users/logoutimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/logout")! 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()
PUT
Update-User
{{baseUrl}}/users/:UserUsername
QUERY PARAMS
UserUsername
BODY json
{
"password": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:UserUsername");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"password\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/users/:UserUsername" {:content-type :json
:form-params {:password ""}})require "http/client"
url = "{{baseUrl}}/users/:UserUsername"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"password\": \"\"\n}"
response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/users/:UserUsername"),
Content = new StringContent("{\n \"password\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/:UserUsername");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"password\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/:UserUsername"
payload := strings.NewReader("{\n \"password\": \"\"\n}")
req, _ := http.NewRequest("PUT", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/users/:UserUsername HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20
{
"password": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/users/:UserUsername")
.setHeader("content-type", "application/json")
.setBody("{\n \"password\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/:UserUsername"))
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("{\n \"password\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"password\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/users/:UserUsername")
.put(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/users/:UserUsername")
.header("content-type", "application/json")
.body("{\n \"password\": \"\"\n}")
.asString(); const data = JSON.stringify({
password: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/users/:UserUsername');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/users/:UserUsername',
headers: {'content-type': 'application/json'},
data: {password: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/:UserUsername';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"password":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/users/:UserUsername',
method: 'PUT',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "password": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"password\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/users/:UserUsername")
.put(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/:UserUsername',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({password: ''}));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/users/:UserUsername',
headers: {'content-type': 'application/json'},
body: {password: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/users/:UserUsername');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
password: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/users/:UserUsername',
headers: {'content-type': 'application/json'},
data: {password: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/:UserUsername';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"password":""}'
};
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/json" };
NSDictionary *parameters = @{ @"password": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users/:UserUsername"]
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}}/users/:UserUsername" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"password\": \"\"\n}" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/:UserUsername",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
'password' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/users/:UserUsername', [
'body' => '{
"password": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/users/:UserUsername');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'password' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'password' => ''
]));
$request->setRequestUrl('{{baseUrl}}/users/:UserUsername');
$request->setRequestMethod('PUT');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:UserUsername' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"password": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:UserUsername' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"password": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"password\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PUT", "/baseUrl/users/:UserUsername", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/:UserUsername"
payload = { "password": "" }
headers = {"content-type": "application/json"}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/:UserUsername"
payload <- "{\n \"password\": \"\"\n}"
encode <- "json"
response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/:UserUsername")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"password\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.put('/baseUrl/users/:UserUsername') do |req|
req.body = "{\n \"password\": \"\"\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/:UserUsername";
let payload = json!({"password": ""});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/users/:UserUsername \
--header 'content-type: application/json' \
--data '{
"password": ""
}'echo '{
"password": ""
}' | \
http PUT {{baseUrl}}/users/:UserUsername \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'content-type: application/json' \
--body-data '{\n "password": ""\n}' \
--output-document \
- {{baseUrl}}/users/:UserUsernameimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["password": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:UserUsername")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"users": [
{
"username": "username"
}
]
}
DELETE
Delete-Profile-Photo
{{baseUrl}}/settings/profile/photo
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/settings/profile/photo");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/settings/profile/photo")require "http/client"
url = "{{baseUrl}}/settings/profile/photo"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/settings/profile/photo"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/settings/profile/photo");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/settings/profile/photo"
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/settings/profile/photo HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/settings/profile/photo")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/settings/profile/photo"))
.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}}/settings/profile/photo")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/settings/profile/photo")
.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}}/settings/profile/photo');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/settings/profile/photo'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/settings/profile/photo';
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}}/settings/profile/photo',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/settings/profile/photo")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/settings/profile/photo',
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}}/settings/profile/photo'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/settings/profile/photo');
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}}/settings/profile/photo'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/settings/profile/photo';
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}}/settings/profile/photo"]
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}}/settings/profile/photo" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/settings/profile/photo",
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}}/settings/profile/photo');
echo $response->getBody();setUrl('{{baseUrl}}/settings/profile/photo');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/settings/profile/photo');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/settings/profile/photo' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/settings/profile/photo' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/settings/profile/photo")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/settings/profile/photo"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/settings/profile/photo"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/settings/profile/photo")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/settings/profile/photo') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/settings/profile/photo";
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}}/settings/profile/photohttp DELETE {{baseUrl}}/settings/profile/photowget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/settings/profile/photoimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/settings/profile/photo")! 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()