Svix API
POST
Create Application
{{baseUrl}}/api/v1/app/
BODY json
{
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/");
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 \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/api/v1/app/" {:content-type :json
:form-params {:metadata {}
:name ""
:rateLimit 0
:uid ""}})require "http/client"
url = "{{baseUrl}}/api/v1/app/"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\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}}/api/v1/app/"),
Content = new StringContent("{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\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}}/api/v1/app/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/"
payload := strings.NewReader("{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\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/api/v1/app/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 65
{
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/app/")
.setHeader("content-type", "application/json")
.setBody("{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\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 \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/app/")
.header("content-type", "application/json")
.body("{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n}")
.asString(); const data = JSON.stringify({
metadata: {},
name: '',
rateLimit: 0,
uid: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/api/v1/app/');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/app/',
headers: {'content-type': 'application/json'},
data: {metadata: {}, name: '', rateLimit: 0, uid: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"metadata":{},"name":"","rateLimit":0,"uid":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "metadata": {},\n "name": "",\n "rateLimit": 0,\n "uid": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/")
.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/api/v1/app/',
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({metadata: {}, name: '', rateLimit: 0, uid: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/app/',
headers: {'content-type': 'application/json'},
body: {metadata: {}, name: '', rateLimit: 0, uid: ''},
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}}/api/v1/app/');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
metadata: {},
name: '',
rateLimit: 0,
uid: ''
});
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}}/api/v1/app/',
headers: {'content-type': 'application/json'},
data: {metadata: {}, name: '', rateLimit: 0, uid: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"metadata":{},"name":"","rateLimit":0,"uid":""}'
};
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 = @{ @"metadata": @{ },
@"name": @"",
@"rateLimit": @0,
@"uid": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/"]
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}}/api/v1/app/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/",
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([
'metadata' => [
],
'name' => '',
'rateLimit' => 0,
'uid' => ''
]),
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}}/api/v1/app/', [
'body' => '{
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'metadata' => [
],
'name' => '',
'rateLimit' => 0,
'uid' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'metadata' => [
],
'name' => '',
'rateLimit' => 0,
'uid' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/app/');
$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}}/api/v1/app/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/api/v1/app/", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/"
payload = {
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/"
payload <- "{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\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}}/api/v1/app/")
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 \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\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/api/v1/app/') do |req|
req.body = "{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/";
let payload = json!({
"metadata": json!({}),
"name": "",
"rateLimit": 0,
"uid": ""
});
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}}/api/v1/app/ \
--header 'content-type: application/json' \
--data '{
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
}'echo '{
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
}' | \
http POST {{baseUrl}}/api/v1/app/ \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "metadata": {},\n "name": "",\n "rateLimit": 0,\n "uid": ""\n}' \
--output-document \
- {{baseUrl}}/api/v1/app/import Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"metadata": [],
"name": "",
"rateLimit": 0,
"uid": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/")! 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
{
"id": "app_1srOrx2ZWZBpBUvZwXKQmoEYga2",
"name": "My first application",
"rateLimit": 1000,
"uid": "unique-app-identifier"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"id": "app_1srOrx2ZWZBpBUvZwXKQmoEYga2",
"name": "My first application",
"rateLimit": 1000,
"uid": "unique-app-identifier"
}
DELETE
Delete Application
{{baseUrl}}/api/v1/app/:app_id/
QUERY PARAMS
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/api/v1/app/:app_id/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/"
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}}/api/v1/app/:app_id/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/api/v1/app/:app_id/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/v1/app/:app_id/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/api/v1/app/:app_id/")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/api/v1/app/:app_id/');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/api/v1/app/:app_id/'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'DELETE', url: '{{baseUrl}}/api/v1/app/:app_id/'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/api/v1/app/:app_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}}/api/v1/app/:app_id/'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/api/v1/app/:app_id/" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/api/v1/app/:app_id/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/api/v1/app/:app_id/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/api/v1/app/:app_id/') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/api/v1/app/:app_id/http DELETE {{baseUrl}}/api/v1/app/:app_id/wget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get Application
{{baseUrl}}/api/v1/app/:app_id/
QUERY PARAMS
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/app/:app_id/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/"
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}}/api/v1/app/:app_id/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/api/v1/app/:app_id/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/app/:app_id/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/app/:app_id/")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/api/v1/app/:app_id/');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/api/v1/app/:app_id/'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/api/v1/app/:app_id/'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/app/:app_id/');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/api/v1/app/:app_id/'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/api/v1/app/:app_id/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/api/v1/app/:app_id/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/app/:app_id/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/api/v1/app/:app_id/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/api/v1/app/:app_id/http GET {{baseUrl}}/api/v1/app/:app_id/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"id": "app_1srOrx2ZWZBpBUvZwXKQmoEYga2",
"name": "My first application",
"rateLimit": 1000,
"uid": "unique-app-identifier"
}
GET
List Applications
{{baseUrl}}/api/v1/app/
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/app/")require "http/client"
url = "{{baseUrl}}/api/v1/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}}/api/v1/app/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/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/api/v1/app/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/app/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/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}}/api/v1/app/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/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}}/api/v1/app/');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/api/v1/app/'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/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}}/api/v1/app/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/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}}/api/v1/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}}/api/v1/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}}/api/v1/app/'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/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}}/api/v1/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}}/api/v1/app/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/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}}/api/v1/app/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/app/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/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/api/v1/app/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/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}}/api/v1/app/http GET {{baseUrl}}/api/v1/app/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/app/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"iterator": "iterator",
"prevIterator": "-iterator"
}
PUT
Update Application
{{baseUrl}}/api/v1/app/:app_id/
QUERY PARAMS
app_id
BODY json
{
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/");
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 \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/api/v1/app/:app_id/" {:content-type :json
:form-params {:metadata {}
:name ""
:rateLimit 0
:uid ""}})require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\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}}/api/v1/app/:app_id/"),
Content = new StringContent("{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\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}}/api/v1/app/:app_id/");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/"
payload := strings.NewReader("{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\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/api/v1/app/:app_id/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 65
{
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/v1/app/:app_id/")
.setHeader("content-type", "application/json")
.setBody("{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/"))
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\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 \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/")
.put(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/api/v1/app/:app_id/")
.header("content-type", "application/json")
.body("{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n}")
.asString(); const data = JSON.stringify({
metadata: {},
name: '',
rateLimit: 0,
uid: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/api/v1/app/:app_id/');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/api/v1/app/:app_id/',
headers: {'content-type': 'application/json'},
data: {metadata: {}, name: '', rateLimit: 0, uid: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"metadata":{},"name":"","rateLimit":0,"uid":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/',
method: 'PUT',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "metadata": {},\n "name": "",\n "rateLimit": 0,\n "uid": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/")
.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/api/v1/app/:app_id/',
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({metadata: {}, name: '', rateLimit: 0, uid: ''}));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/api/v1/app/:app_id/',
headers: {'content-type': 'application/json'},
body: {metadata: {}, name: '', rateLimit: 0, uid: ''},
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}}/api/v1/app/:app_id/');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
metadata: {},
name: '',
rateLimit: 0,
uid: ''
});
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}}/api/v1/app/:app_id/',
headers: {'content-type': 'application/json'},
data: {metadata: {}, name: '', rateLimit: 0, uid: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"metadata":{},"name":"","rateLimit":0,"uid":""}'
};
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 = @{ @"metadata": @{ },
@"name": @"",
@"rateLimit": @0,
@"uid": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/api/v1/app/:app_id/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n}" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
'metadata' => [
],
'name' => '',
'rateLimit' => 0,
'uid' => ''
]),
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}}/api/v1/app/:app_id/', [
'body' => '{
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'metadata' => [
],
'name' => '',
'rateLimit' => 0,
'uid' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'metadata' => [
],
'name' => '',
'rateLimit' => 0,
'uid' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/');
$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}}/api/v1/app/:app_id/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PUT", "/baseUrl/api/v1/app/:app_id/", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/"
payload = {
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
}
headers = {"content-type": "application/json"}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/"
payload <- "{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\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}}/api/v1/app/:app_id/")
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 \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\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/api/v1/app/:app_id/') do |req|
req.body = "{\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\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}}/api/v1/app/:app_id/";
let payload = json!({
"metadata": json!({}),
"name": "",
"rateLimit": 0,
"uid": ""
});
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}}/api/v1/app/:app_id/ \
--header 'content-type: application/json' \
--data '{
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
}'echo '{
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
}' | \
http PUT {{baseUrl}}/api/v1/app/:app_id/ \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'content-type: application/json' \
--body-data '{\n "metadata": {},\n "name": "",\n "rateLimit": 0,\n "uid": ""\n}' \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/import Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"metadata": [],
"name": "",
"rateLimit": 0,
"uid": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"id": "app_1srOrx2ZWZBpBUvZwXKQmoEYga2",
"name": "My first application",
"rateLimit": 1000,
"uid": "unique-app-identifier"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"id": "app_1srOrx2ZWZBpBUvZwXKQmoEYga2",
"name": "My first application",
"rateLimit": 1000,
"uid": "unique-app-identifier"
}
POST
Expire All
{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/
QUERY PARAMS
app_id
BODY json
{
"expiry": 0
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/");
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 \"expiry\": 60\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/" {:content-type :json
:form-params {:expiry 60}})require "http/client"
url = "{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"expiry\": 60\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}}/api/v1/auth/app/:app_id/expire-all/"),
Content = new StringContent("{\n \"expiry\": 60\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}}/api/v1/auth/app/:app_id/expire-all/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"expiry\": 60\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/"
payload := strings.NewReader("{\n \"expiry\": 60\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/api/v1/auth/app/:app_id/expire-all/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 18
{
"expiry": 60
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/")
.setHeader("content-type", "application/json")
.setBody("{\n \"expiry\": 60\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"expiry\": 60\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 \"expiry\": 60\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/")
.header("content-type", "application/json")
.body("{\n \"expiry\": 60\n}")
.asString(); const data = JSON.stringify({
expiry: 60
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/',
headers: {'content-type': 'application/json'},
data: {expiry: 60}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"expiry":60}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "expiry": 60\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"expiry\": 60\n}")
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/")
.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/api/v1/auth/app/:app_id/expire-all/',
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({expiry: 60}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/',
headers: {'content-type': 'application/json'},
body: {expiry: 60},
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}}/api/v1/auth/app/:app_id/expire-all/');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
expiry: 60
});
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}}/api/v1/auth/app/:app_id/expire-all/',
headers: {'content-type': 'application/json'},
data: {expiry: 60}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"expiry":60}'
};
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 = @{ @"expiry": @60 };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/"]
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}}/api/v1/auth/app/:app_id/expire-all/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"expiry\": 60\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/",
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([
'expiry' => 60
]),
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}}/api/v1/auth/app/:app_id/expire-all/', [
'body' => '{
"expiry": 60
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'expiry' => 60
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'expiry' => 60
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/');
$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}}/api/v1/auth/app/:app_id/expire-all/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"expiry": 60
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"expiry": 60
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"expiry\": 60\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/api/v1/auth/app/:app_id/expire-all/", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/"
payload = { "expiry": 60 }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/"
payload <- "{\n \"expiry\": 60\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}}/api/v1/auth/app/:app_id/expire-all/")
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 \"expiry\": 60\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/api/v1/auth/app/:app_id/expire-all/') do |req|
req.body = "{\n \"expiry\": 60\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/";
let payload = json!({"expiry": 60});
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}}/api/v1/auth/app/:app_id/expire-all/ \
--header 'content-type: application/json' \
--data '{
"expiry": 60
}'echo '{
"expiry": 60
}' | \
http POST {{baseUrl}}/api/v1/auth/app/:app_id/expire-all/ \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "expiry": 60\n}' \
--output-document \
- {{baseUrl}}/api/v1/auth/app/:app_id/expire-all/import Foundation
let headers = ["content-type": "application/json"]
let parameters = ["expiry": 60] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/auth/app/:app_id/expire-all/")! 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
Get Consumer App Portal Access
{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/
QUERY PARAMS
app_id
BODY json
{
"featureFlags": []
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/");
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 \"featureFlags\": []\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/" {:content-type :json
:form-params {:featureFlags []}})require "http/client"
url = "{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"featureFlags\": []\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}}/api/v1/auth/app-portal-access/:app_id/"),
Content = new StringContent("{\n \"featureFlags\": []\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}}/api/v1/auth/app-portal-access/:app_id/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"featureFlags\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/"
payload := strings.NewReader("{\n \"featureFlags\": []\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/api/v1/auth/app-portal-access/:app_id/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 24
{
"featureFlags": []
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/")
.setHeader("content-type", "application/json")
.setBody("{\n \"featureFlags\": []\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"featureFlags\": []\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 \"featureFlags\": []\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/")
.header("content-type", "application/json")
.body("{\n \"featureFlags\": []\n}")
.asString(); const data = JSON.stringify({
featureFlags: []
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/',
headers: {'content-type': 'application/json'},
data: {featureFlags: []}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"featureFlags":[]}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "featureFlags": []\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"featureFlags\": []\n}")
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/")
.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/api/v1/auth/app-portal-access/:app_id/',
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({featureFlags: []}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/',
headers: {'content-type': 'application/json'},
body: {featureFlags: []},
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}}/api/v1/auth/app-portal-access/:app_id/');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
featureFlags: []
});
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}}/api/v1/auth/app-portal-access/:app_id/',
headers: {'content-type': 'application/json'},
data: {featureFlags: []}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"featureFlags":[]}'
};
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 = @{ @"featureFlags": @[ ] };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/"]
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}}/api/v1/auth/app-portal-access/:app_id/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"featureFlags\": []\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/",
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([
'featureFlags' => [
]
]),
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}}/api/v1/auth/app-portal-access/:app_id/', [
'body' => '{
"featureFlags": []
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'featureFlags' => [
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'featureFlags' => [
]
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/');
$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}}/api/v1/auth/app-portal-access/:app_id/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"featureFlags": []
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"featureFlags": []
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"featureFlags\": []\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/api/v1/auth/app-portal-access/:app_id/", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/"
payload = { "featureFlags": [] }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/"
payload <- "{\n \"featureFlags\": []\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}}/api/v1/auth/app-portal-access/:app_id/")
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 \"featureFlags\": []\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/api/v1/auth/app-portal-access/:app_id/') do |req|
req.body = "{\n \"featureFlags\": []\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/";
let payload = json!({"featureFlags": ()});
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}}/api/v1/auth/app-portal-access/:app_id/ \
--header 'content-type: application/json' \
--data '{
"featureFlags": []
}'echo '{
"featureFlags": []
}' | \
http POST {{baseUrl}}/api/v1/auth/app-portal-access/:app_id/ \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "featureFlags": []\n}' \
--output-document \
- {{baseUrl}}/api/v1/auth/app-portal-access/:app_id/import Foundation
let headers = ["content-type": "application/json"]
let parameters = ["featureFlags": []] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/auth/app-portal-access/:app_id/")! 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
{
"token": "appsk_kV3ts5tKPNJN4Dl25cMTfUNdmabxbX0O",
"url": "https://app.svix.com/login#key=eyJhcHBJZCI6ICJhcHBfMXRSdFl"
}
POST
Get Dashboard Access
{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/
QUERY PARAMS
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/")require "http/client"
url = "{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/"
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}}/api/v1/auth/dashboard-access/:app_id/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/api/v1/auth/dashboard-access/:app_id/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/auth/dashboard-access/:app_id/',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/api/v1/auth/dashboard-access/:app_id/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/api/v1/auth/dashboard-access/:app_id/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/";
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}}/api/v1/auth/dashboard-access/:app_id/http POST {{baseUrl}}/api/v1/auth/dashboard-access/:app_id/wget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/api/v1/auth/dashboard-access/:app_id/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/auth/dashboard-access/:app_id/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"token": "appsk_kV3ts5tKPNJN4Dl25cMTfUNdmabxbX0O",
"url": "https://app.svix.com/login#key=eyJhcHBJZCI6ICJhcHBfMXRSdFl"
}
POST
Logout
{{baseUrl}}/api/v1/auth/logout/
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/auth/logout/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/api/v1/auth/logout/")require "http/client"
url = "{{baseUrl}}/api/v1/auth/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}}/api/v1/auth/logout/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/auth/logout/");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/auth/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/api/v1/auth/logout/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/auth/logout/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/auth/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}}/api/v1/auth/logout/")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/auth/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}}/api/v1/auth/logout/');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/api/v1/auth/logout/'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/auth/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}}/api/v1/auth/logout/',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/auth/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/api/v1/auth/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}}/api/v1/auth/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}}/api/v1/auth/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}}/api/v1/auth/logout/'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/auth/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}}/api/v1/auth/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}}/api/v1/auth/logout/" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/auth/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}}/api/v1/auth/logout/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/auth/logout/');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/auth/logout/');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/auth/logout/' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/auth/logout/' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/api/v1/auth/logout/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/auth/logout/"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/auth/logout/"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/auth/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/api/v1/auth/logout/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/auth/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}}/api/v1/auth/logout/http POST {{baseUrl}}/api/v1/auth/logout/wget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/api/v1/auth/logout/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/auth/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()
GET
Get Background Task
{{baseUrl}}/api/v1/background-task/:task_id/
QUERY PARAMS
task_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/background-task/:task_id/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/background-task/:task_id/")require "http/client"
url = "{{baseUrl}}/api/v1/background-task/:task_id/"
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}}/api/v1/background-task/:task_id/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/background-task/:task_id/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/background-task/:task_id/"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/api/v1/background-task/:task_id/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/background-task/:task_id/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/background-task/:task_id/"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/background-task/:task_id/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/background-task/:task_id/")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/api/v1/background-task/:task_id/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/background-task/:task_id/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/background-task/:task_id/';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/background-task/:task_id/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/background-task/:task_id/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/background-task/:task_id/',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/background-task/:task_id/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/background-task/:task_id/');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/background-task/:task_id/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/background-task/:task_id/';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/background-task/:task_id/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/api/v1/background-task/:task_id/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/background-task/:task_id/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/api/v1/background-task/:task_id/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/background-task/:task_id/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/background-task/:task_id/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/background-task/:task_id/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/background-task/:task_id/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/background-task/:task_id/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/background-task/:task_id/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/background-task/:task_id/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/background-task/:task_id/")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/api/v1/background-task/:task_id/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/background-task/:task_id/";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/api/v1/background-task/:task_id/http GET {{baseUrl}}/api/v1/background-task/:task_id/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/background-task/:task_id/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/background-task/:task_id/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"id": "qtask_1srOrx2ZWZBpBUvZwXKQmoEYga2"
}
GET
List Background Tasks
{{baseUrl}}/api/v1/background-task/
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/background-task/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/background-task/")require "http/client"
url = "{{baseUrl}}/api/v1/background-task/"
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}}/api/v1/background-task/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/background-task/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/background-task/"
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/api/v1/background-task/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/background-task/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/background-task/"))
.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}}/api/v1/background-task/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/background-task/")
.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}}/api/v1/background-task/');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/api/v1/background-task/'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/background-task/';
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}}/api/v1/background-task/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/background-task/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/background-task/',
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}}/api/v1/background-task/'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/background-task/');
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}}/api/v1/background-task/'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/background-task/';
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}}/api/v1/background-task/"]
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}}/api/v1/background-task/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/background-task/",
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}}/api/v1/background-task/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/background-task/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/background-task/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/background-task/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/background-task/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/background-task/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/background-task/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/background-task/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/background-task/")
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/api/v1/background-task/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/background-task/";
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}}/api/v1/background-task/http GET {{baseUrl}}/api/v1/background-task/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/background-task/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/background-task/")! 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
{
"iterator": "iterator",
"prevIterator": "-iterator"
}
POST
Create Endpoint
{{baseUrl}}/api/v1/app/:app_id/endpoint/
QUERY PARAMS
app_id
BODY json
{
"channels": [],
"description": "",
"disabled": false,
"filterTypes": [],
"metadata": {},
"rateLimit": 0,
"secret": "",
"uid": "",
"url": "",
"version": 0
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/endpoint/");
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 \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"secret\": \"\",\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/api/v1/app/:app_id/endpoint/" {:content-type :json
:form-params {:channels []
:description ""
:disabled false
:filterTypes []
:metadata {}
:rateLimit 0
:secret ""
:uid ""
:url ""
:version 0}})require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"secret\": \"\",\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\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}}/api/v1/app/:app_id/endpoint/"),
Content = new StringContent("{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"secret\": \"\",\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\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}}/api/v1/app/:app_id/endpoint/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"secret\": \"\",\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/endpoint/"
payload := strings.NewReader("{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"secret\": \"\",\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\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/api/v1/app/:app_id/endpoint/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 177
{
"channels": [],
"description": "",
"disabled": false,
"filterTypes": [],
"metadata": {},
"rateLimit": 0,
"secret": "",
"uid": "",
"url": "",
"version": 0
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/app/:app_id/endpoint/")
.setHeader("content-type", "application/json")
.setBody("{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"secret\": \"\",\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/endpoint/"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"secret\": \"\",\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\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 \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"secret\": \"\",\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/app/:app_id/endpoint/")
.header("content-type", "application/json")
.body("{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"secret\": \"\",\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\n}")
.asString(); const data = JSON.stringify({
channels: [],
description: '',
disabled: false,
filterTypes: [],
metadata: {},
rateLimit: 0,
secret: '',
uid: '',
url: '',
version: 0
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/api/v1/app/:app_id/endpoint/');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/',
headers: {'content-type': 'application/json'},
data: {
channels: [],
description: '',
disabled: false,
filterTypes: [],
metadata: {},
rateLimit: 0,
secret: '',
uid: '',
url: '',
version: 0
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"channels":[],"description":"","disabled":false,"filterTypes":[],"metadata":{},"rateLimit":0,"secret":"","uid":"","url":"","version":0}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "channels": [],\n "description": "",\n "disabled": false,\n "filterTypes": [],\n "metadata": {},\n "rateLimit": 0,\n "secret": "",\n "uid": "",\n "url": "",\n "version": 0\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"secret\": \"\",\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\n}")
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/")
.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/api/v1/app/:app_id/endpoint/',
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({
channels: [],
description: '',
disabled: false,
filterTypes: [],
metadata: {},
rateLimit: 0,
secret: '',
uid: '',
url: '',
version: 0
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/',
headers: {'content-type': 'application/json'},
body: {
channels: [],
description: '',
disabled: false,
filterTypes: [],
metadata: {},
rateLimit: 0,
secret: '',
uid: '',
url: '',
version: 0
},
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}}/api/v1/app/:app_id/endpoint/');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
channels: [],
description: '',
disabled: false,
filterTypes: [],
metadata: {},
rateLimit: 0,
secret: '',
uid: '',
url: '',
version: 0
});
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}}/api/v1/app/:app_id/endpoint/',
headers: {'content-type': 'application/json'},
data: {
channels: [],
description: '',
disabled: false,
filterTypes: [],
metadata: {},
rateLimit: 0,
secret: '',
uid: '',
url: '',
version: 0
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"channels":[],"description":"","disabled":false,"filterTypes":[],"metadata":{},"rateLimit":0,"secret":"","uid":"","url":"","version":0}'
};
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 = @{ @"channels": @[ ],
@"description": @"",
@"disabled": @NO,
@"filterTypes": @[ ],
@"metadata": @{ },
@"rateLimit": @0,
@"secret": @"",
@"uid": @"",
@"url": @"",
@"version": @0 };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/endpoint/"]
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}}/api/v1/app/:app_id/endpoint/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"secret\": \"\",\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/endpoint/",
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([
'channels' => [
],
'description' => '',
'disabled' => null,
'filterTypes' => [
],
'metadata' => [
],
'rateLimit' => 0,
'secret' => '',
'uid' => '',
'url' => '',
'version' => 0
]),
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}}/api/v1/app/:app_id/endpoint/', [
'body' => '{
"channels": [],
"description": "",
"disabled": false,
"filterTypes": [],
"metadata": {},
"rateLimit": 0,
"secret": "",
"uid": "",
"url": "",
"version": 0
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'channels' => [
],
'description' => '',
'disabled' => null,
'filterTypes' => [
],
'metadata' => [
],
'rateLimit' => 0,
'secret' => '',
'uid' => '',
'url' => '',
'version' => 0
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'channels' => [
],
'description' => '',
'disabled' => null,
'filterTypes' => [
],
'metadata' => [
],
'rateLimit' => 0,
'secret' => '',
'uid' => '',
'url' => '',
'version' => 0
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/');
$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}}/api/v1/app/:app_id/endpoint/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"channels": [],
"description": "",
"disabled": false,
"filterTypes": [],
"metadata": {},
"rateLimit": 0,
"secret": "",
"uid": "",
"url": "",
"version": 0
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"channels": [],
"description": "",
"disabled": false,
"filterTypes": [],
"metadata": {},
"rateLimit": 0,
"secret": "",
"uid": "",
"url": "",
"version": 0
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"secret\": \"\",\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/api/v1/app/:app_id/endpoint/", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/"
payload = {
"channels": [],
"description": "",
"disabled": False,
"filterTypes": [],
"metadata": {},
"rateLimit": 0,
"secret": "",
"uid": "",
"url": "",
"version": 0
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/endpoint/"
payload <- "{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"secret\": \"\",\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\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}}/api/v1/app/:app_id/endpoint/")
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 \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"secret\": \"\",\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\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/api/v1/app/:app_id/endpoint/') do |req|
req.body = "{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"secret\": \"\",\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/";
let payload = json!({
"channels": (),
"description": "",
"disabled": false,
"filterTypes": (),
"metadata": json!({}),
"rateLimit": 0,
"secret": "",
"uid": "",
"url": "",
"version": 0
});
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}}/api/v1/app/:app_id/endpoint/ \
--header 'content-type: application/json' \
--data '{
"channels": [],
"description": "",
"disabled": false,
"filterTypes": [],
"metadata": {},
"rateLimit": 0,
"secret": "",
"uid": "",
"url": "",
"version": 0
}'echo '{
"channels": [],
"description": "",
"disabled": false,
"filterTypes": [],
"metadata": {},
"rateLimit": 0,
"secret": "",
"uid": "",
"url": "",
"version": 0
}' | \
http POST {{baseUrl}}/api/v1/app/:app_id/endpoint/ \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "channels": [],\n "description": "",\n "disabled": false,\n "filterTypes": [],\n "metadata": {},\n "rateLimit": 0,\n "secret": "",\n "uid": "",\n "url": "",\n "version": 0\n}' \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/endpoint/import Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"channels": [],
"description": "",
"disabled": false,
"filterTypes": [],
"metadata": [],
"rateLimit": 0,
"secret": "",
"uid": "",
"url": "",
"version": 0
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/endpoint/")! 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
{
"channels": [
"project_123",
"group_2"
],
"description": "An example endpoint name",
"disabled": false,
"filterTypes": [
"user.signup",
"user.deleted"
],
"id": "ep_1srOrx2ZWZBpBUvZwXKQmoEYga2",
"rateLimit": 1000,
"uid": "unique-endpoint-identifier",
"url": "https://example.com/webhook/",
"version": 1
}
DELETE
Delete Endpoint
{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/
QUERY PARAMS
endpoint_id
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/"
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_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}}/api/v1/app/:app_id/endpoint/:endpoint_id/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/http DELETE {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/wget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get Endpoint Headers
{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/
QUERY PARAMS
endpoint_id
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"
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/api/v1/app/:app_id/endpoint/:endpoint_id/headers/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"))
.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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/")
.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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/';
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/headers/',
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/');
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/';
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"]
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/",
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/headers/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/")
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/api/v1/app/:app_id/endpoint/:endpoint_id/headers/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/";
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/http GET {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/")! 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
{
"headers": {
"X-Example": "123",
"X-Foobar": "Bar"
},
"sensitive": [
"Authorization"
]
}
GET
Get Endpoint Secret
{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/
QUERY PARAMS
endpoint_id
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/"
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/"
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/api/v1/app/:app_id/endpoint/:endpoint_id/secret/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/"))
.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}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/")
.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}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/';
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/secret/',
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/');
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/';
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/"]
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/",
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/secret/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/")
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/api/v1/app/:app_id/endpoint/:endpoint_id/secret/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/";
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/http GET {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/")! 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
{
"key": "whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD"
}
GET
Get Endpoint Stats
{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/
QUERY PARAMS
endpoint_id
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/"
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/"
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/api/v1/app/:app_id/endpoint/:endpoint_id/stats/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/"))
.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}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/")
.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}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/';
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/stats/',
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/');
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/';
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/"]
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/",
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/stats/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/")
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/api/v1/app/:app_id/endpoint/:endpoint_id/stats/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/";
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/http GET {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/stats/")! 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 Endpoint Transformation
{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/
QUERY PARAMS
endpoint_id
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/"
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/"
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/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/"))
.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}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/")
.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}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/';
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/',
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/');
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/';
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/"]
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/",
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/")
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/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/";
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/http GET {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/")! 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 Endpoint
{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/
QUERY PARAMS
endpoint_id
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/"
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/http GET {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"channels": [
"project_123",
"group_2"
],
"description": "An example endpoint name",
"disabled": false,
"filterTypes": [
"user.signup",
"user.deleted"
],
"id": "ep_1srOrx2ZWZBpBUvZwXKQmoEYga2",
"rateLimit": 1000,
"uid": "unique-endpoint-identifier",
"url": "https://example.com/webhook/",
"version": 1
}
GET
List Endpoints
{{baseUrl}}/api/v1/app/:app_id/endpoint/
QUERY PARAMS
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/endpoint/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/app/:app_id/endpoint/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/"
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}}/api/v1/app/:app_id/endpoint/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/endpoint/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/endpoint/"
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/api/v1/app/:app_id/endpoint/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/app/:app_id/endpoint/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/endpoint/"))
.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}}/api/v1/app/:app_id/endpoint/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/app/:app_id/endpoint/")
.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}}/api/v1/app/:app_id/endpoint/');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/';
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}}/api/v1/app/:app_id/endpoint/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/endpoint/',
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}}/api/v1/app/:app_id/endpoint/'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/app/:app_id/endpoint/');
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}}/api/v1/app/:app_id/endpoint/'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/';
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}}/api/v1/app/:app_id/endpoint/"]
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}}/api/v1/app/:app_id/endpoint/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/endpoint/",
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}}/api/v1/app/:app_id/endpoint/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/app/:app_id/endpoint/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/endpoint/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/endpoint/")
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/api/v1/app/:app_id/endpoint/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/";
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}}/api/v1/app/:app_id/endpoint/http GET {{baseUrl}}/api/v1/app/:app_id/endpoint/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/endpoint/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/endpoint/")! 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
{
"iterator": "iterator",
"prevIterator": "-iterator"
}
PATCH
Patch Endpoint Headers
{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/
QUERY PARAMS
app_id
endpoint_id
BODY json
{
"headers": {}
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/");
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 \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\n }\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/" {:content-type :json
:form-params {:headers {:X-Example "123"
:X-Foobar "Bar"}}})require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"),
Content = new StringContent("{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\n }\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"
payload := strings.NewReader("{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\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/api/v1/app/:app_id/endpoint/:endpoint_id/headers/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 68
{
"headers": {
"X-Example": "123",
"X-Foobar": "Bar"
}
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/")
.setHeader("content-type", "application/json")
.setBody("{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\n }\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"))
.header("content-type", "application/json")
.method("PATCH", HttpRequest.BodyPublishers.ofString("{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\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 \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\n }\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/")
.patch(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/")
.header("content-type", "application/json")
.body("{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\n }\n}")
.asString(); const data = JSON.stringify({
headers: {
'X-Example': '123',
'X-Foobar': 'Bar'
}
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/',
headers: {'content-type': 'application/json'},
data: {headers: {'X-Example': '123', 'X-Foobar': 'Bar'}}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"headers":{"X-Example":"123","X-Foobar":"Bar"}}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/',
method: 'PATCH',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "headers": {\n "X-Example": "123",\n "X-Foobar": "Bar"\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 \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\n }\n}")
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/")
.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/api/v1/app/:app_id/endpoint/:endpoint_id/headers/',
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({headers: {'X-Example': '123', 'X-Foobar': 'Bar'}}));
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/',
headers: {'content-type': 'application/json'},
body: {headers: {'X-Example': '123', 'X-Foobar': 'Bar'}},
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
headers: {
'X-Example': '123',
'X-Foobar': 'Bar'
}
});
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/',
headers: {'content-type': 'application/json'},
data: {headers: {'X-Example': '123', 'X-Foobar': 'Bar'}}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"headers":{"X-Example":"123","X-Foobar":"Bar"}}'
};
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 = @{ @"headers": @{ @"X-Example": @"123", @"X-Foobar": @"Bar" } };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"]
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\n }\n}" in
Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/",
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([
'headers' => [
'X-Example' => '123',
'X-Foobar' => 'Bar'
]
]),
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/', [
'body' => '{
"headers": {
"X-Example": "123",
"X-Foobar": "Bar"
}
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'headers' => [
'X-Example' => '123',
'X-Foobar' => 'Bar'
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'headers' => [
'X-Example' => '123',
'X-Foobar' => 'Bar'
]
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/');
$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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"headers": {
"X-Example": "123",
"X-Foobar": "Bar"
}
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"headers": {
"X-Example": "123",
"X-Foobar": "Bar"
}
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\n }\n}"
headers = { 'content-type': "application/json" }
conn.request("PATCH", "/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/headers/", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"
payload = { "headers": {
"X-Example": "123",
"X-Foobar": "Bar"
} }
headers = {"content-type": "application/json"}
response = requests.patch(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"
payload <- "{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/")
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 \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\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/api/v1/app/:app_id/endpoint/:endpoint_id/headers/') do |req|
req.body = "{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/";
let payload = json!({"headers": json!({
"X-Example": "123",
"X-Foobar": "Bar"
})});
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/ \
--header 'content-type: application/json' \
--data '{
"headers": {
"X-Example": "123",
"X-Foobar": "Bar"
}
}'echo '{
"headers": {
"X-Example": "123",
"X-Foobar": "Bar"
}
}' | \
http PATCH {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/ \
content-type:application/jsonwget --quiet \
--method PATCH \
--header 'content-type: application/json' \
--body-data '{\n "headers": {\n "X-Example": "123",\n "X-Foobar": "Bar"\n }\n}' \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/import Foundation
let headers = ["content-type": "application/json"]
let parameters = ["headers": [
"X-Example": "123",
"X-Foobar": "Bar"
]] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/")! 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
Recover Failed Webhooks
{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/
QUERY PARAMS
app_id
endpoint_id
BODY json
{
"since": "",
"until": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/");
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 \"since\": \"\",\n \"until\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/" {:content-type :json
:form-params {:since ""
:until ""}})require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"since\": \"\",\n \"until\": \"\"\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/"),
Content = new StringContent("{\n \"since\": \"\",\n \"until\": \"\"\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"since\": \"\",\n \"until\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/"
payload := strings.NewReader("{\n \"since\": \"\",\n \"until\": \"\"\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/api/v1/app/:app_id/endpoint/:endpoint_id/recover/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 32
{
"since": "",
"until": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/")
.setHeader("content-type", "application/json")
.setBody("{\n \"since\": \"\",\n \"until\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"since\": \"\",\n \"until\": \"\"\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 \"since\": \"\",\n \"until\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/")
.header("content-type", "application/json")
.body("{\n \"since\": \"\",\n \"until\": \"\"\n}")
.asString(); const data = JSON.stringify({
since: '',
until: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/',
headers: {'content-type': 'application/json'},
data: {since: '', until: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"since":"","until":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "since": "",\n "until": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"since\": \"\",\n \"until\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/")
.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/api/v1/app/:app_id/endpoint/:endpoint_id/recover/',
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({since: '', until: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/',
headers: {'content-type': 'application/json'},
body: {since: '', until: ''},
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
since: '',
until: ''
});
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/',
headers: {'content-type': 'application/json'},
data: {since: '', until: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"since":"","until":""}'
};
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 = @{ @"since": @"",
@"until": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/"]
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"since\": \"\",\n \"until\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/",
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([
'since' => '',
'until' => ''
]),
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/', [
'body' => '{
"since": "",
"until": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'since' => '',
'until' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'since' => '',
'until' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/');
$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}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"since": "",
"until": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"since": "",
"until": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"since\": \"\",\n \"until\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/recover/", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/"
payload = {
"since": "",
"until": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/"
payload <- "{\n \"since\": \"\",\n \"until\": \"\"\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/")
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 \"since\": \"\",\n \"until\": \"\"\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/api/v1/app/:app_id/endpoint/:endpoint_id/recover/') do |req|
req.body = "{\n \"since\": \"\",\n \"until\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/";
let payload = json!({
"since": "",
"until": ""
});
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/ \
--header 'content-type: application/json' \
--data '{
"since": "",
"until": ""
}'echo '{
"since": "",
"until": ""
}' | \
http POST {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/ \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "since": "",\n "until": ""\n}' \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/import Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"since": "",
"until": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/recover/")! 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
{
"id": "qtask_1srOrx2ZWZBpBUvZwXKQmoEYga2"
}
POST
Replay Missing Webhooks
{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/
QUERY PARAMS
app_id
endpoint_id
BODY json
{
"since": "",
"until": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/");
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 \"since\": \"\",\n \"until\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/" {:content-type :json
:form-params {:since ""
:until ""}})require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"since\": \"\",\n \"until\": \"\"\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/"),
Content = new StringContent("{\n \"since\": \"\",\n \"until\": \"\"\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"since\": \"\",\n \"until\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/"
payload := strings.NewReader("{\n \"since\": \"\",\n \"until\": \"\"\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/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 32
{
"since": "",
"until": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/")
.setHeader("content-type", "application/json")
.setBody("{\n \"since\": \"\",\n \"until\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"since\": \"\",\n \"until\": \"\"\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 \"since\": \"\",\n \"until\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/")
.header("content-type", "application/json")
.body("{\n \"since\": \"\",\n \"until\": \"\"\n}")
.asString(); const data = JSON.stringify({
since: '',
until: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/',
headers: {'content-type': 'application/json'},
data: {since: '', until: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"since":"","until":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "since": "",\n "until": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"since\": \"\",\n \"until\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/")
.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/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/',
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({since: '', until: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/',
headers: {'content-type': 'application/json'},
body: {since: '', until: ''},
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
since: '',
until: ''
});
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/',
headers: {'content-type': 'application/json'},
data: {since: '', until: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"since":"","until":""}'
};
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 = @{ @"since": @"",
@"until": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/"]
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"since\": \"\",\n \"until\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/",
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([
'since' => '',
'until' => ''
]),
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/', [
'body' => '{
"since": "",
"until": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'since' => '',
'until' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'since' => '',
'until' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/');
$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}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"since": "",
"until": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"since": "",
"until": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"since\": \"\",\n \"until\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/"
payload = {
"since": "",
"until": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/"
payload <- "{\n \"since\": \"\",\n \"until\": \"\"\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/")
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 \"since\": \"\",\n \"until\": \"\"\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/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/') do |req|
req.body = "{\n \"since\": \"\",\n \"until\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/";
let payload = json!({
"since": "",
"until": ""
});
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/ \
--header 'content-type: application/json' \
--data '{
"since": "",
"until": ""
}'echo '{
"since": "",
"until": ""
}' | \
http POST {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/ \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "since": "",\n "until": ""\n}' \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/import Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"since": "",
"until": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/replay-missing/")! 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
{
"id": "qtask_1srOrx2ZWZBpBUvZwXKQmoEYga2"
}
POST
Rotate Endpoint Secret
{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/
QUERY PARAMS
endpoint_id
app_id
BODY json
{
"key": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/");
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 \"key\": \"whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/" {:content-type :json
:form-params {:key "whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD"}})require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"key\": \"whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD\"\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/"),
Content = new StringContent("{\n \"key\": \"whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD\"\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"key\": \"whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/"
payload := strings.NewReader("{\n \"key\": \"whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD\"\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/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 53
{
"key": "whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD"
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/")
.setHeader("content-type", "application/json")
.setBody("{\n \"key\": \"whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"key\": \"whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD\"\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 \"key\": \"whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/")
.header("content-type", "application/json")
.body("{\n \"key\": \"whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD\"\n}")
.asString(); const data = JSON.stringify({
key: 'whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD'
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/',
headers: {'content-type': 'application/json'},
data: {key: 'whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"key":"whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD"}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "key": "whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD"\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"key\": \"whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/")
.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/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/',
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({key: 'whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD'}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/',
headers: {'content-type': 'application/json'},
body: {key: 'whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD'},
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
key: 'whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD'
});
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/',
headers: {'content-type': 'application/json'},
data: {key: 'whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"key":"whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD"}'
};
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 = @{ @"key": @"whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/"]
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"key\": \"whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/",
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([
'key' => 'whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD'
]),
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/', [
'body' => '{
"key": "whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD"
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'key' => 'whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD'
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'key' => 'whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD'
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/');
$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}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"key": "whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD"
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"key": "whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD"
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"key\": \"whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/"
payload = { "key": "whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD" }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/"
payload <- "{\n \"key\": \"whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD\"\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/")
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 \"key\": \"whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD\"\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/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/') do |req|
req.body = "{\n \"key\": \"whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/";
let payload = json!({"key": "whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD"});
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/ \
--header 'content-type: application/json' \
--data '{
"key": "whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD"
}'echo '{
"key": "whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD"
}' | \
http POST {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/ \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "key": "whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD"\n}' \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/import Foundation
let headers = ["content-type": "application/json"]
let parameters = ["key": "whsec_C2FVsBQIhrscChlQIMV+b5sSYspob7oD"] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/secret/rotate/")! 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
Set Endpoint Transformation
{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/
QUERY PARAMS
app_id
endpoint_id
BODY json
{
"code": "",
"enabled": false
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/");
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 \"enabled\": false\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/" {:content-type :json
:form-params {:code ""
:enabled false}})require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"code\": \"\",\n \"enabled\": false\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/"),
Content = new StringContent("{\n \"code\": \"\",\n \"enabled\": false\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"code\": \"\",\n \"enabled\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/"
payload := strings.NewReader("{\n \"code\": \"\",\n \"enabled\": false\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/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 36
{
"code": "",
"enabled": false
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/")
.setHeader("content-type", "application/json")
.setBody("{\n \"code\": \"\",\n \"enabled\": false\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/"))
.header("content-type", "application/json")
.method("PATCH", HttpRequest.BodyPublishers.ofString("{\n \"code\": \"\",\n \"enabled\": false\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 \"enabled\": false\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/")
.patch(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/")
.header("content-type", "application/json")
.body("{\n \"code\": \"\",\n \"enabled\": false\n}")
.asString(); const data = JSON.stringify({
code: '',
enabled: false
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/',
headers: {'content-type': 'application/json'},
data: {code: '', enabled: false}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"code":"","enabled":false}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/',
method: 'PATCH',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "code": "",\n "enabled": false\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 \"enabled\": false\n}")
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/")
.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/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/',
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: '', enabled: false}));
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/',
headers: {'content-type': 'application/json'},
body: {code: '', enabled: false},
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
code: '',
enabled: false
});
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/',
headers: {'content-type': 'application/json'},
data: {code: '', enabled: false}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"code":"","enabled":false}'
};
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": @"",
@"enabled": @NO };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/"]
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"code\": \"\",\n \"enabled\": false\n}" in
Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/",
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([
'code' => '',
'enabled' => null
]),
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/', [
'body' => '{
"code": "",
"enabled": false
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'code' => '',
'enabled' => null
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'code' => '',
'enabled' => null
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/');
$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}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"code": "",
"enabled": false
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"code": "",
"enabled": false
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"code\": \"\",\n \"enabled\": false\n}"
headers = { 'content-type': "application/json" }
conn.request("PATCH", "/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/"
payload = {
"code": "",
"enabled": False
}
headers = {"content-type": "application/json"}
response = requests.patch(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/"
payload <- "{\n \"code\": \"\",\n \"enabled\": false\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/")
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 \"code\": \"\",\n \"enabled\": false\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/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/') do |req|
req.body = "{\n \"code\": \"\",\n \"enabled\": false\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/";
let payload = json!({
"code": "",
"enabled": false
});
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/ \
--header 'content-type: application/json' \
--data '{
"code": "",
"enabled": false
}'echo '{
"code": "",
"enabled": false
}' | \
http PATCH {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/ \
content-type:application/jsonwget --quiet \
--method PATCH \
--header 'content-type: application/json' \
--body-data '{\n "code": "",\n "enabled": false\n}' \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/import Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"code": "",
"enabled": false
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/transformation/")! 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()
PUT
Update Endpoint Headers
{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/
QUERY PARAMS
app_id
endpoint_id
BODY json
{
"headers": {}
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/");
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 \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\n }\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/" {:content-type :json
:form-params {:headers {:X-Example "123"
:X-Foobar "Bar"}}})require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\n }\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"),
Content = new StringContent("{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\n }\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"
payload := strings.NewReader("{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\n }\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/api/v1/app/:app_id/endpoint/:endpoint_id/headers/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 68
{
"headers": {
"X-Example": "123",
"X-Foobar": "Bar"
}
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/")
.setHeader("content-type", "application/json")
.setBody("{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\n }\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"))
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\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 \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\n }\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/")
.put(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/")
.header("content-type", "application/json")
.body("{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\n }\n}")
.asString(); const data = JSON.stringify({
headers: {
'X-Example': '123',
'X-Foobar': 'Bar'
}
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/',
headers: {'content-type': 'application/json'},
data: {headers: {'X-Example': '123', 'X-Foobar': 'Bar'}}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"headers":{"X-Example":"123","X-Foobar":"Bar"}}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/',
method: 'PUT',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "headers": {\n "X-Example": "123",\n "X-Foobar": "Bar"\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 \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\n }\n}")
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/")
.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/api/v1/app/:app_id/endpoint/:endpoint_id/headers/',
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({headers: {'X-Example': '123', 'X-Foobar': 'Bar'}}));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/',
headers: {'content-type': 'application/json'},
body: {headers: {'X-Example': '123', 'X-Foobar': 'Bar'}},
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
headers: {
'X-Example': '123',
'X-Foobar': 'Bar'
}
});
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/',
headers: {'content-type': 'application/json'},
data: {headers: {'X-Example': '123', 'X-Foobar': 'Bar'}}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"headers":{"X-Example":"123","X-Foobar":"Bar"}}'
};
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 = @{ @"headers": @{ @"X-Example": @"123", @"X-Foobar": @"Bar" } };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"]
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\n }\n}" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/",
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([
'headers' => [
'X-Example' => '123',
'X-Foobar' => 'Bar'
]
]),
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/', [
'body' => '{
"headers": {
"X-Example": "123",
"X-Foobar": "Bar"
}
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'headers' => [
'X-Example' => '123',
'X-Foobar' => 'Bar'
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'headers' => [
'X-Example' => '123',
'X-Foobar' => 'Bar'
]
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/');
$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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"headers": {
"X-Example": "123",
"X-Foobar": "Bar"
}
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"headers": {
"X-Example": "123",
"X-Foobar": "Bar"
}
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\n }\n}"
headers = { 'content-type': "application/json" }
conn.request("PUT", "/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/headers/", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"
payload = { "headers": {
"X-Example": "123",
"X-Foobar": "Bar"
} }
headers = {"content-type": "application/json"}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/"
payload <- "{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\n }\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/")
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 \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\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.put('/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/headers/') do |req|
req.body = "{\n \"headers\": {\n \"X-Example\": \"123\",\n \"X-Foobar\": \"Bar\"\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/";
let payload = json!({"headers": json!({
"X-Example": "123",
"X-Foobar": "Bar"
})});
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/ \
--header 'content-type: application/json' \
--data '{
"headers": {
"X-Example": "123",
"X-Foobar": "Bar"
}
}'echo '{
"headers": {
"X-Example": "123",
"X-Foobar": "Bar"
}
}' | \
http PUT {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/ \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'content-type: application/json' \
--body-data '{\n "headers": {\n "X-Example": "123",\n "X-Foobar": "Bar"\n }\n}' \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/import Foundation
let headers = ["content-type": "application/json"]
let parameters = ["headers": [
"X-Example": "123",
"X-Foobar": "Bar"
]] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/headers/")! 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()
PUT
Update Endpoint
{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/
QUERY PARAMS
endpoint_id
app_id
BODY json
{
"channels": [],
"description": "",
"disabled": false,
"filterTypes": [],
"metadata": {},
"rateLimit": 0,
"uid": "",
"url": "",
"version": 0
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/");
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 \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/" {:content-type :json
:form-params {:channels []
:description ""
:disabled false
:filterTypes []
:metadata {}
:rateLimit 0
:uid ""
:url ""
:version 0}})require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/"),
Content = new StringContent("{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/"
payload := strings.NewReader("{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\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/api/v1/app/:app_id/endpoint/:endpoint_id/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 161
{
"channels": [],
"description": "",
"disabled": false,
"filterTypes": [],
"metadata": {},
"rateLimit": 0,
"uid": "",
"url": "",
"version": 0
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/")
.setHeader("content-type", "application/json")
.setBody("{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/"))
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\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 \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/")
.put(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/")
.header("content-type", "application/json")
.body("{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\n}")
.asString(); const data = JSON.stringify({
channels: [],
description: '',
disabled: false,
filterTypes: [],
metadata: {},
rateLimit: 0,
uid: '',
url: '',
version: 0
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/',
headers: {'content-type': 'application/json'},
data: {
channels: [],
description: '',
disabled: false,
filterTypes: [],
metadata: {},
rateLimit: 0,
uid: '',
url: '',
version: 0
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"channels":[],"description":"","disabled":false,"filterTypes":[],"metadata":{},"rateLimit":0,"uid":"","url":"","version":0}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/',
method: 'PUT',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "channels": [],\n "description": "",\n "disabled": false,\n "filterTypes": [],\n "metadata": {},\n "rateLimit": 0,\n "uid": "",\n "url": "",\n "version": 0\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\n}")
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/")
.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/api/v1/app/:app_id/endpoint/:endpoint_id/',
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({
channels: [],
description: '',
disabled: false,
filterTypes: [],
metadata: {},
rateLimit: 0,
uid: '',
url: '',
version: 0
}));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/',
headers: {'content-type': 'application/json'},
body: {
channels: [],
description: '',
disabled: false,
filterTypes: [],
metadata: {},
rateLimit: 0,
uid: '',
url: '',
version: 0
},
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
channels: [],
description: '',
disabled: false,
filterTypes: [],
metadata: {},
rateLimit: 0,
uid: '',
url: '',
version: 0
});
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/',
headers: {'content-type': 'application/json'},
data: {
channels: [],
description: '',
disabled: false,
filterTypes: [],
metadata: {},
rateLimit: 0,
uid: '',
url: '',
version: 0
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"channels":[],"description":"","disabled":false,"filterTypes":[],"metadata":{},"rateLimit":0,"uid":"","url":"","version":0}'
};
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 = @{ @"channels": @[ ],
@"description": @"",
@"disabled": @NO,
@"filterTypes": @[ ],
@"metadata": @{ },
@"rateLimit": @0,
@"uid": @"",
@"url": @"",
@"version": @0 };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\n}" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
'channels' => [
],
'description' => '',
'disabled' => null,
'filterTypes' => [
],
'metadata' => [
],
'rateLimit' => 0,
'uid' => '',
'url' => '',
'version' => 0
]),
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/', [
'body' => '{
"channels": [],
"description": "",
"disabled": false,
"filterTypes": [],
"metadata": {},
"rateLimit": 0,
"uid": "",
"url": "",
"version": 0
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'channels' => [
],
'description' => '',
'disabled' => null,
'filterTypes' => [
],
'metadata' => [
],
'rateLimit' => 0,
'uid' => '',
'url' => '',
'version' => 0
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'channels' => [
],
'description' => '',
'disabled' => null,
'filterTypes' => [
],
'metadata' => [
],
'rateLimit' => 0,
'uid' => '',
'url' => '',
'version' => 0
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/');
$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}}/api/v1/app/:app_id/endpoint/:endpoint_id/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"channels": [],
"description": "",
"disabled": false,
"filterTypes": [],
"metadata": {},
"rateLimit": 0,
"uid": "",
"url": "",
"version": 0
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"channels": [],
"description": "",
"disabled": false,
"filterTypes": [],
"metadata": {},
"rateLimit": 0,
"uid": "",
"url": "",
"version": 0
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\n}"
headers = { 'content-type': "application/json" }
conn.request("PUT", "/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/"
payload = {
"channels": [],
"description": "",
"disabled": False,
"filterTypes": [],
"metadata": {},
"rateLimit": 0,
"uid": "",
"url": "",
"version": 0
}
headers = {"content-type": "application/json"}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/"
payload <- "{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/")
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 \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\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/api/v1/app/:app_id/endpoint/:endpoint_id/') do |req|
req.body = "{\n \"channels\": [],\n \"description\": \"\",\n \"disabled\": false,\n \"filterTypes\": [],\n \"metadata\": {},\n \"rateLimit\": 0,\n \"uid\": \"\",\n \"url\": \"\",\n \"version\": 0\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}}/api/v1/app/:app_id/endpoint/:endpoint_id/";
let payload = json!({
"channels": (),
"description": "",
"disabled": false,
"filterTypes": (),
"metadata": json!({}),
"rateLimit": 0,
"uid": "",
"url": "",
"version": 0
});
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/ \
--header 'content-type: application/json' \
--data '{
"channels": [],
"description": "",
"disabled": false,
"filterTypes": [],
"metadata": {},
"rateLimit": 0,
"uid": "",
"url": "",
"version": 0
}'echo '{
"channels": [],
"description": "",
"disabled": false,
"filterTypes": [],
"metadata": {},
"rateLimit": 0,
"uid": "",
"url": "",
"version": 0
}' | \
http PUT {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/ \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'content-type: application/json' \
--body-data '{\n "channels": [],\n "description": "",\n "disabled": false,\n "filterTypes": [],\n "metadata": {},\n "rateLimit": 0,\n "uid": "",\n "url": "",\n "version": 0\n}' \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/import Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"channels": [],
"description": "",
"disabled": false,
"filterTypes": [],
"metadata": [],
"rateLimit": 0,
"uid": "",
"url": "",
"version": 0
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"channels": [
"project_123",
"group_2"
],
"description": "An example endpoint name",
"disabled": false,
"filterTypes": [
"user.signup",
"user.deleted"
],
"id": "ep_1srOrx2ZWZBpBUvZwXKQmoEYga2",
"rateLimit": 1000,
"uid": "unique-endpoint-identifier",
"url": "https://example.com/webhook/",
"version": 1
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"channels": [
"project_123",
"group_2"
],
"description": "An example endpoint name",
"disabled": false,
"filterTypes": [
"user.signup",
"user.deleted"
],
"id": "ep_1srOrx2ZWZBpBUvZwXKQmoEYga2",
"rateLimit": 1000,
"uid": "unique-endpoint-identifier",
"url": "https://example.com/webhook/",
"version": 1
}
DELETE
Archive Event Type
{{baseUrl}}/api/v1/event-type/:event_type_name/
QUERY PARAMS
event_type_name
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/event-type/:event_type_name/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/api/v1/event-type/:event_type_name/")require "http/client"
url = "{{baseUrl}}/api/v1/event-type/:event_type_name/"
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}}/api/v1/event-type/:event_type_name/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/event-type/:event_type_name/");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/event-type/:event_type_name/"
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/api/v1/event-type/:event_type_name/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/v1/event-type/:event_type_name/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/event-type/:event_type_name/"))
.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}}/api/v1/event-type/:event_type_name/")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/api/v1/event-type/:event_type_name/")
.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}}/api/v1/event-type/:event_type_name/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/api/v1/event-type/:event_type_name/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/event-type/:event_type_name/';
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}}/api/v1/event-type/:event_type_name/',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/event-type/:event_type_name/")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/event-type/:event_type_name/',
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}}/api/v1/event-type/:event_type_name/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/api/v1/event-type/:event_type_name/');
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}}/api/v1/event-type/:event_type_name/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/event-type/:event_type_name/';
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}}/api/v1/event-type/:event_type_name/"]
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}}/api/v1/event-type/:event_type_name/" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/event-type/:event_type_name/",
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}}/api/v1/event-type/:event_type_name/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/event-type/:event_type_name/');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/event-type/:event_type_name/');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/event-type/:event_type_name/' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/event-type/:event_type_name/' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/api/v1/event-type/:event_type_name/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/event-type/:event_type_name/"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/event-type/:event_type_name/"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/event-type/:event_type_name/")
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/api/v1/event-type/:event_type_name/') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/event-type/:event_type_name/";
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}}/api/v1/event-type/:event_type_name/http DELETE {{baseUrl}}/api/v1/event-type/:event_type_name/wget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/api/v1/event-type/:event_type_name/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/event-type/:event_type_name/")! 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
Create Event Type
{{baseUrl}}/api/v1/event-type/
BODY json
{
"archived": false,
"description": "",
"featureFlag": "",
"name": "",
"schemas": {}
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/event-type/");
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 \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"name\": \"\",\n \"schemas\": {}\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/api/v1/event-type/" {:content-type :json
:form-params {:archived false
:description ""
:featureFlag ""
:name ""
:schemas {}}})require "http/client"
url = "{{baseUrl}}/api/v1/event-type/"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"name\": \"\",\n \"schemas\": {}\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}}/api/v1/event-type/"),
Content = new StringContent("{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"name\": \"\",\n \"schemas\": {}\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}}/api/v1/event-type/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"name\": \"\",\n \"schemas\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/event-type/"
payload := strings.NewReader("{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"name\": \"\",\n \"schemas\": {}\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/api/v1/event-type/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 96
{
"archived": false,
"description": "",
"featureFlag": "",
"name": "",
"schemas": {}
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/event-type/")
.setHeader("content-type", "application/json")
.setBody("{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"name\": \"\",\n \"schemas\": {}\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/event-type/"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"name\": \"\",\n \"schemas\": {}\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 \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"name\": \"\",\n \"schemas\": {}\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/event-type/")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/event-type/")
.header("content-type", "application/json")
.body("{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"name\": \"\",\n \"schemas\": {}\n}")
.asString(); const data = JSON.stringify({
archived: false,
description: '',
featureFlag: '',
name: '',
schemas: {}
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/api/v1/event-type/');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/event-type/',
headers: {'content-type': 'application/json'},
data: {archived: false, description: '', featureFlag: '', name: '', schemas: {}}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/event-type/';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"archived":false,"description":"","featureFlag":"","name":"","schemas":{}}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/event-type/',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "archived": false,\n "description": "",\n "featureFlag": "",\n "name": "",\n "schemas": {}\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"name\": \"\",\n \"schemas\": {}\n}")
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/event-type/")
.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/api/v1/event-type/',
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({archived: false, description: '', featureFlag: '', name: '', schemas: {}}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/event-type/',
headers: {'content-type': 'application/json'},
body: {archived: false, description: '', featureFlag: '', name: '', schemas: {}},
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}}/api/v1/event-type/');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
archived: false,
description: '',
featureFlag: '',
name: '',
schemas: {}
});
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}}/api/v1/event-type/',
headers: {'content-type': 'application/json'},
data: {archived: false, description: '', featureFlag: '', name: '', schemas: {}}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/event-type/';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"archived":false,"description":"","featureFlag":"","name":"","schemas":{}}'
};
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 = @{ @"archived": @NO,
@"description": @"",
@"featureFlag": @"",
@"name": @"",
@"schemas": @{ } };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/event-type/"]
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}}/api/v1/event-type/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"name\": \"\",\n \"schemas\": {}\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/event-type/",
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([
'archived' => null,
'description' => '',
'featureFlag' => '',
'name' => '',
'schemas' => [
]
]),
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}}/api/v1/event-type/', [
'body' => '{
"archived": false,
"description": "",
"featureFlag": "",
"name": "",
"schemas": {}
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/event-type/');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'archived' => null,
'description' => '',
'featureFlag' => '',
'name' => '',
'schemas' => [
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'archived' => null,
'description' => '',
'featureFlag' => '',
'name' => '',
'schemas' => [
]
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/event-type/');
$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}}/api/v1/event-type/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"archived": false,
"description": "",
"featureFlag": "",
"name": "",
"schemas": {}
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/event-type/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"archived": false,
"description": "",
"featureFlag": "",
"name": "",
"schemas": {}
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"name\": \"\",\n \"schemas\": {}\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/api/v1/event-type/", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/event-type/"
payload = {
"archived": False,
"description": "",
"featureFlag": "",
"name": "",
"schemas": {}
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/event-type/"
payload <- "{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"name\": \"\",\n \"schemas\": {}\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}}/api/v1/event-type/")
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 \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"name\": \"\",\n \"schemas\": {}\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/api/v1/event-type/') do |req|
req.body = "{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"name\": \"\",\n \"schemas\": {}\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/event-type/";
let payload = json!({
"archived": false,
"description": "",
"featureFlag": "",
"name": "",
"schemas": 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}}/api/v1/event-type/ \
--header 'content-type: application/json' \
--data '{
"archived": false,
"description": "",
"featureFlag": "",
"name": "",
"schemas": {}
}'echo '{
"archived": false,
"description": "",
"featureFlag": "",
"name": "",
"schemas": {}
}' | \
http POST {{baseUrl}}/api/v1/event-type/ \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "archived": false,\n "description": "",\n "featureFlag": "",\n "name": "",\n "schemas": {}\n}' \
--output-document \
- {{baseUrl}}/api/v1/event-type/import Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"archived": false,
"description": "",
"featureFlag": "",
"name": "",
"schemas": []
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/event-type/")! 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
{
"archived": false,
"description": "A user has signed up",
"featureFlag": "cool-new-feature",
"name": "user.signup",
"schemas": {
"1": {
"description": "An invoice was paid by a user",
"properties": {
"invoiceId": {
"description": "The invoice id",
"type": "string"
},
"userId": {
"description": "The user id",
"type": "string"
}
},
"required": [
"invoiceId",
"userId"
],
"title": "Invoice Paid Event",
"type": "object"
}
}
}
GET
Get Event Type
{{baseUrl}}/api/v1/event-type/:event_type_name/
QUERY PARAMS
event_type_name
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/event-type/:event_type_name/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/event-type/:event_type_name/")require "http/client"
url = "{{baseUrl}}/api/v1/event-type/:event_type_name/"
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}}/api/v1/event-type/:event_type_name/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/event-type/:event_type_name/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/event-type/:event_type_name/"
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/api/v1/event-type/:event_type_name/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/event-type/:event_type_name/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/event-type/:event_type_name/"))
.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}}/api/v1/event-type/:event_type_name/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/event-type/:event_type_name/")
.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}}/api/v1/event-type/:event_type_name/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/event-type/:event_type_name/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/event-type/:event_type_name/';
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}}/api/v1/event-type/:event_type_name/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/event-type/:event_type_name/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/event-type/:event_type_name/',
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}}/api/v1/event-type/:event_type_name/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/event-type/:event_type_name/');
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}}/api/v1/event-type/:event_type_name/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/event-type/:event_type_name/';
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}}/api/v1/event-type/:event_type_name/"]
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}}/api/v1/event-type/:event_type_name/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/event-type/:event_type_name/",
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}}/api/v1/event-type/:event_type_name/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/event-type/:event_type_name/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/event-type/:event_type_name/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/event-type/:event_type_name/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/event-type/:event_type_name/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/event-type/:event_type_name/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/event-type/:event_type_name/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/event-type/:event_type_name/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/event-type/:event_type_name/")
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/api/v1/event-type/:event_type_name/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/event-type/:event_type_name/";
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}}/api/v1/event-type/:event_type_name/http GET {{baseUrl}}/api/v1/event-type/:event_type_name/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/event-type/:event_type_name/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/event-type/:event_type_name/")! 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
{
"archived": false,
"description": "A user has signed up",
"featureFlag": "cool-new-feature",
"name": "user.signup",
"schemas": {
"1": {
"description": "An invoice was paid by a user",
"properties": {
"invoiceId": {
"description": "The invoice id",
"type": "string"
},
"userId": {
"description": "The user id",
"type": "string"
}
},
"required": [
"invoiceId",
"userId"
],
"title": "Invoice Paid Event",
"type": "object"
}
}
}
GET
List Event Types
{{baseUrl}}/api/v1/event-type/
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/event-type/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/event-type/")require "http/client"
url = "{{baseUrl}}/api/v1/event-type/"
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}}/api/v1/event-type/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/event-type/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/event-type/"
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/api/v1/event-type/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/event-type/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/event-type/"))
.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}}/api/v1/event-type/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/event-type/")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/api/v1/event-type/');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/api/v1/event-type/'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/event-type/';
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}}/api/v1/event-type/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/event-type/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/event-type/',
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}}/api/v1/event-type/'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/event-type/');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/api/v1/event-type/'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/event-type/';
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}}/api/v1/event-type/"]
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}}/api/v1/event-type/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/event-type/",
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}}/api/v1/event-type/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/event-type/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/event-type/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/event-type/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/event-type/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/event-type/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/event-type/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/event-type/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/event-type/")
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/api/v1/event-type/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/event-type/";
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}}/api/v1/event-type/http GET {{baseUrl}}/api/v1/event-type/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/event-type/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/event-type/")! 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
{
"iterator": "iterator",
"prevIterator": "-iterator"
}
PUT
Update Event Type
{{baseUrl}}/api/v1/event-type/:event_type_name/
QUERY PARAMS
event_type_name
BODY json
{
"archived": false,
"description": "",
"featureFlag": "",
"schemas": {}
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/event-type/:event_type_name/");
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 \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"schemas\": {}\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/api/v1/event-type/:event_type_name/" {:content-type :json
:form-params {:archived false
:description ""
:featureFlag ""
:schemas {}}})require "http/client"
url = "{{baseUrl}}/api/v1/event-type/:event_type_name/"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"schemas\": {}\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}}/api/v1/event-type/:event_type_name/"),
Content = new StringContent("{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"schemas\": {}\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}}/api/v1/event-type/:event_type_name/");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"schemas\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/event-type/:event_type_name/"
payload := strings.NewReader("{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"schemas\": {}\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/api/v1/event-type/:event_type_name/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 82
{
"archived": false,
"description": "",
"featureFlag": "",
"schemas": {}
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/v1/event-type/:event_type_name/")
.setHeader("content-type", "application/json")
.setBody("{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"schemas\": {}\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/event-type/:event_type_name/"))
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"schemas\": {}\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 \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"schemas\": {}\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/event-type/:event_type_name/")
.put(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/api/v1/event-type/:event_type_name/")
.header("content-type", "application/json")
.body("{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"schemas\": {}\n}")
.asString(); const data = JSON.stringify({
archived: false,
description: '',
featureFlag: '',
schemas: {}
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/api/v1/event-type/:event_type_name/');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/api/v1/event-type/:event_type_name/',
headers: {'content-type': 'application/json'},
data: {archived: false, description: '', featureFlag: '', schemas: {}}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/event-type/:event_type_name/';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"archived":false,"description":"","featureFlag":"","schemas":{}}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/event-type/:event_type_name/',
method: 'PUT',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "archived": false,\n "description": "",\n "featureFlag": "",\n "schemas": {}\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"schemas\": {}\n}")
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/event-type/:event_type_name/")
.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/api/v1/event-type/:event_type_name/',
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({archived: false, description: '', featureFlag: '', schemas: {}}));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/api/v1/event-type/:event_type_name/',
headers: {'content-type': 'application/json'},
body: {archived: false, description: '', featureFlag: '', schemas: {}},
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}}/api/v1/event-type/:event_type_name/');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
archived: false,
description: '',
featureFlag: '',
schemas: {}
});
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}}/api/v1/event-type/:event_type_name/',
headers: {'content-type': 'application/json'},
data: {archived: false, description: '', featureFlag: '', schemas: {}}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/event-type/:event_type_name/';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"archived":false,"description":"","featureFlag":"","schemas":{}}'
};
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 = @{ @"archived": @NO,
@"description": @"",
@"featureFlag": @"",
@"schemas": @{ } };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/event-type/:event_type_name/"]
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}}/api/v1/event-type/:event_type_name/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"schemas\": {}\n}" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/event-type/:event_type_name/",
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([
'archived' => null,
'description' => '',
'featureFlag' => '',
'schemas' => [
]
]),
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}}/api/v1/event-type/:event_type_name/', [
'body' => '{
"archived": false,
"description": "",
"featureFlag": "",
"schemas": {}
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/event-type/:event_type_name/');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'archived' => null,
'description' => '',
'featureFlag' => '',
'schemas' => [
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'archived' => null,
'description' => '',
'featureFlag' => '',
'schemas' => [
]
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/event-type/:event_type_name/');
$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}}/api/v1/event-type/:event_type_name/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"archived": false,
"description": "",
"featureFlag": "",
"schemas": {}
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/event-type/:event_type_name/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"archived": false,
"description": "",
"featureFlag": "",
"schemas": {}
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"schemas\": {}\n}"
headers = { 'content-type': "application/json" }
conn.request("PUT", "/baseUrl/api/v1/event-type/:event_type_name/", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/event-type/:event_type_name/"
payload = {
"archived": False,
"description": "",
"featureFlag": "",
"schemas": {}
}
headers = {"content-type": "application/json"}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/event-type/:event_type_name/"
payload <- "{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"schemas\": {}\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}}/api/v1/event-type/:event_type_name/")
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 \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"schemas\": {}\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/api/v1/event-type/:event_type_name/') do |req|
req.body = "{\n \"archived\": false,\n \"description\": \"\",\n \"featureFlag\": \"\",\n \"schemas\": {}\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}}/api/v1/event-type/:event_type_name/";
let payload = json!({
"archived": false,
"description": "",
"featureFlag": "",
"schemas": json!({})
});
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}}/api/v1/event-type/:event_type_name/ \
--header 'content-type: application/json' \
--data '{
"archived": false,
"description": "",
"featureFlag": "",
"schemas": {}
}'echo '{
"archived": false,
"description": "",
"featureFlag": "",
"schemas": {}
}' | \
http PUT {{baseUrl}}/api/v1/event-type/:event_type_name/ \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'content-type: application/json' \
--body-data '{\n "archived": false,\n "description": "",\n "featureFlag": "",\n "schemas": {}\n}' \
--output-document \
- {{baseUrl}}/api/v1/event-type/:event_type_name/import Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"archived": false,
"description": "",
"featureFlag": "",
"schemas": []
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/event-type/:event_type_name/")! 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
{
"archived": false,
"description": "A user has signed up",
"featureFlag": "cool-new-feature",
"name": "user.signup",
"schemas": {
"1": {
"description": "An invoice was paid by a user",
"properties": {
"invoiceId": {
"description": "The invoice id",
"type": "string"
},
"userId": {
"description": "The user id",
"type": "string"
}
},
"required": [
"invoiceId",
"userId"
],
"title": "Invoice Paid Event",
"type": "object"
}
}
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"archived": false,
"description": "A user has signed up",
"featureFlag": "cool-new-feature",
"name": "user.signup",
"schemas": {
"1": {
"description": "An invoice was paid by a user",
"properties": {
"invoiceId": {
"description": "The invoice id",
"type": "string"
},
"userId": {
"description": "The user id",
"type": "string"
}
},
"required": [
"invoiceId",
"userId"
],
"title": "Invoice Paid Event",
"type": "object"
}
}
}
GET
Health
{{baseUrl}}/api/v1/health/
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/health/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/health/")require "http/client"
url = "{{baseUrl}}/api/v1/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}}/api/v1/health/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/health/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/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/api/v1/health/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/health/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/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}}/api/v1/health/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/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}}/api/v1/health/');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/api/v1/health/'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/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}}/api/v1/health/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/health/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/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}}/api/v1/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}}/api/v1/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}}/api/v1/health/'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/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}}/api/v1/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}}/api/v1/health/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/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}}/api/v1/health/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/health/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/health/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/health/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/health/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/health/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/health/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/health/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/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/api/v1/health/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/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}}/api/v1/health/http GET {{baseUrl}}/api/v1/health/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/health/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/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()
POST
Create Integration
{{baseUrl}}/api/v1/app/:app_id/integration/
QUERY PARAMS
app_id
BODY json
{
"name": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/integration/");
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 \"name\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/api/v1/app/:app_id/integration/" {:content-type :json
:form-params {:name ""}})require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/integration/"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"name\": \"\"\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}}/api/v1/app/:app_id/integration/"),
Content = new StringContent("{\n \"name\": \"\"\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}}/api/v1/app/:app_id/integration/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/integration/"
payload := strings.NewReader("{\n \"name\": \"\"\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/api/v1/app/:app_id/integration/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16
{
"name": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/app/:app_id/integration/")
.setHeader("content-type", "application/json")
.setBody("{\n \"name\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/integration/"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"name\": \"\"\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 \"name\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/integration/")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/app/:app_id/integration/")
.header("content-type", "application/json")
.body("{\n \"name\": \"\"\n}")
.asString(); const data = JSON.stringify({
name: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/api/v1/app/:app_id/integration/');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/app/:app_id/integration/',
headers: {'content-type': 'application/json'},
data: {name: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/integration/';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"name":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/integration/',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "name": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"name\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/integration/")
.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/api/v1/app/:app_id/integration/',
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({name: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/app/:app_id/integration/',
headers: {'content-type': 'application/json'},
body: {name: ''},
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}}/api/v1/app/:app_id/integration/');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
name: ''
});
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}}/api/v1/app/:app_id/integration/',
headers: {'content-type': 'application/json'},
data: {name: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/integration/';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"name":""}'
};
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 = @{ @"name": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/integration/"]
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}}/api/v1/app/:app_id/integration/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"name\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/integration/",
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([
'name' => ''
]),
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}}/api/v1/app/:app_id/integration/', [
'body' => '{
"name": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/integration/');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'name' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/integration/');
$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}}/api/v1/app/:app_id/integration/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"name": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/integration/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"name": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"name\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/api/v1/app/:app_id/integration/", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/integration/"
payload = { "name": "" }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/integration/"
payload <- "{\n \"name\": \"\"\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}}/api/v1/app/:app_id/integration/")
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 \"name\": \"\"\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/api/v1/app/:app_id/integration/') do |req|
req.body = "{\n \"name\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/integration/";
let payload = json!({"name": ""});
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}}/api/v1/app/:app_id/integration/ \
--header 'content-type: application/json' \
--data '{
"name": ""
}'echo '{
"name": ""
}' | \
http POST {{baseUrl}}/api/v1/app/:app_id/integration/ \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "name": ""\n}' \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/integration/import Foundation
let headers = ["content-type": "application/json"]
let parameters = ["name": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/integration/")! 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
{
"id": "integ_1srOrx2ZWZBpBUvZwXKQmoEYga2",
"name": "Example Integration"
}
DELETE
Delete Integration
{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/
QUERY PARAMS
integ_id
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/"
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}}/api/v1/app/:app_id/integration/:integ_id/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/api/v1/app/:app_id/integration/:integ_id/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/integration/:integ_id/',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_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}}/api/v1/app/:app_id/integration/:integ_id/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/api/v1/app/:app_id/integration/:integ_id/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/api/v1/app/:app_id/integration/:integ_id/') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/http DELETE {{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/wget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get Integration Key
{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/
QUERY PARAMS
integ_id
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/"
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}}/api/v1/app/:app_id/integration/:integ_id/key/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/"
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/api/v1/app/:app_id/integration/:integ_id/key/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/"))
.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}}/api/v1/app/:app_id/integration/:integ_id/key/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/")
.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}}/api/v1/app/:app_id/integration/:integ_id/key/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/';
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}}/api/v1/app/:app_id/integration/:integ_id/key/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/integration/:integ_id/key/',
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}}/api/v1/app/:app_id/integration/:integ_id/key/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/');
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}}/api/v1/app/:app_id/integration/:integ_id/key/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/';
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}}/api/v1/app/:app_id/integration/:integ_id/key/"]
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}}/api/v1/app/:app_id/integration/:integ_id/key/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/",
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}}/api/v1/app/:app_id/integration/:integ_id/key/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/app/:app_id/integration/:integ_id/key/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/")
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/api/v1/app/:app_id/integration/:integ_id/key/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/";
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}}/api/v1/app/:app_id/integration/:integ_id/key/http GET {{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/")! 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
{
"key": "integsk_kV3ts5tKPNJN4Dl25cMTfUNdmabxbX0O"
}
GET
Get Integration
{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/
QUERY PARAMS
integ_id
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/"
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}}/api/v1/app/:app_id/integration/:integ_id/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/api/v1/app/:app_id/integration/:integ_id/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/integration/:integ_id/',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/app/:app_id/integration/:integ_id/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/api/v1/app/:app_id/integration/:integ_id/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/http GET {{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"id": "integ_1srOrx2ZWZBpBUvZwXKQmoEYga2",
"name": "Example Integration"
}
GET
List Integrations
{{baseUrl}}/api/v1/app/:app_id/integration/
QUERY PARAMS
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/integration/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/app/:app_id/integration/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/integration/"
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}}/api/v1/app/:app_id/integration/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/integration/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/integration/"
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/api/v1/app/:app_id/integration/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/app/:app_id/integration/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/integration/"))
.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}}/api/v1/app/:app_id/integration/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/app/:app_id/integration/")
.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}}/api/v1/app/:app_id/integration/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/integration/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/integration/';
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}}/api/v1/app/:app_id/integration/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/integration/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/integration/',
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}}/api/v1/app/:app_id/integration/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/app/:app_id/integration/');
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}}/api/v1/app/:app_id/integration/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/integration/';
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}}/api/v1/app/:app_id/integration/"]
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}}/api/v1/app/:app_id/integration/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/integration/",
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}}/api/v1/app/:app_id/integration/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/integration/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/integration/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/integration/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/integration/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/app/:app_id/integration/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/integration/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/integration/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/integration/")
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/api/v1/app/:app_id/integration/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/integration/";
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}}/api/v1/app/:app_id/integration/http GET {{baseUrl}}/api/v1/app/:app_id/integration/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/integration/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/integration/")! 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
{
"iterator": "iterator"
}
POST
Rotate Integration Key
{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/
QUERY PARAMS
integ_id
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/"
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}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/"
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/api/v1/app/:app_id/integration/:integ_id/key/rotate/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/"))
.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}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/")
.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}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/';
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}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/integration/:integ_id/key/rotate/',
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}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/');
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}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/';
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}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/"]
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}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/",
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}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/api/v1/app/:app_id/integration/:integ_id/key/rotate/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/")
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/api/v1/app/:app_id/integration/:integ_id/key/rotate/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/";
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}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/http POST {{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/wget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/key/rotate/")! 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
{
"key": "integsk_kV3ts5tKPNJN4Dl25cMTfUNdmabxbX0O"
}
PUT
Update Integration
{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/
QUERY PARAMS
integ_id
app_id
BODY json
{
"name": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/");
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 \"name\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/" {:content-type :json
:form-params {:name ""}})require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"name\": \"\"\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}}/api/v1/app/:app_id/integration/:integ_id/"),
Content = new StringContent("{\n \"name\": \"\"\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}}/api/v1/app/:app_id/integration/:integ_id/");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/"
payload := strings.NewReader("{\n \"name\": \"\"\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/api/v1/app/:app_id/integration/:integ_id/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16
{
"name": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/")
.setHeader("content-type", "application/json")
.setBody("{\n \"name\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/"))
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("{\n \"name\": \"\"\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 \"name\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/")
.put(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/")
.header("content-type", "application/json")
.body("{\n \"name\": \"\"\n}")
.asString(); const data = JSON.stringify({
name: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/',
headers: {'content-type': 'application/json'},
data: {name: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"name":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/',
method: 'PUT',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "name": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"name\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/")
.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/api/v1/app/:app_id/integration/:integ_id/',
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({name: ''}));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/',
headers: {'content-type': 'application/json'},
body: {name: ''},
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}}/api/v1/app/:app_id/integration/:integ_id/');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
name: ''
});
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}}/api/v1/app/:app_id/integration/:integ_id/',
headers: {'content-type': 'application/json'},
data: {name: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/';
const options = {
method: 'PUT',
headers: {'content-type': 'application/json'},
body: '{"name":""}'
};
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 = @{ @"name": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"name\": \"\"\n}" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
'name' => ''
]),
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}}/api/v1/app/:app_id/integration/:integ_id/', [
'body' => '{
"name": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'name' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/');
$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}}/api/v1/app/:app_id/integration/:integ_id/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"name": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"name": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"name\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PUT", "/baseUrl/api/v1/app/:app_id/integration/:integ_id/", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/"
payload = { "name": "" }
headers = {"content-type": "application/json"}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/"
payload <- "{\n \"name\": \"\"\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}}/api/v1/app/:app_id/integration/:integ_id/")
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 \"name\": \"\"\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/api/v1/app/:app_id/integration/:integ_id/') do |req|
req.body = "{\n \"name\": \"\"\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}}/api/v1/app/:app_id/integration/:integ_id/";
let payload = json!({"name": ""});
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}}/api/v1/app/:app_id/integration/:integ_id/ \
--header 'content-type: application/json' \
--data '{
"name": ""
}'echo '{
"name": ""
}' | \
http PUT {{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/ \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'content-type: application/json' \
--body-data '{\n "name": ""\n}' \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/import Foundation
let headers = ["content-type": "application/json"]
let parameters = ["name": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/integration/:integ_id/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"id": "integ_1srOrx2ZWZBpBUvZwXKQmoEYga2",
"name": "Example Integration"
}
POST
Create Message
{{baseUrl}}/api/v1/app/:app_id/msg/
QUERY PARAMS
app_id
BODY json
{
"application": {
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
},
"channels": [],
"eventId": "",
"eventType": "",
"payload": {},
"payloadRetentionPeriod": 0
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/msg/");
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 \"application\": {\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n },\n \"channels\": [],\n \"eventId\": \"\",\n \"eventType\": \"\",\n \"payload\": {},\n \"payloadRetentionPeriod\": 0\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/api/v1/app/:app_id/msg/" {:content-type :json
:form-params {:application {:metadata {}
:name ""
:rateLimit 0
:uid ""}
:channels []
:eventId ""
:eventType ""
:payload {}
:payloadRetentionPeriod 0}})require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/msg/"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"application\": {\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n },\n \"channels\": [],\n \"eventId\": \"\",\n \"eventType\": \"\",\n \"payload\": {},\n \"payloadRetentionPeriod\": 0\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}}/api/v1/app/:app_id/msg/"),
Content = new StringContent("{\n \"application\": {\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n },\n \"channels\": [],\n \"eventId\": \"\",\n \"eventType\": \"\",\n \"payload\": {},\n \"payloadRetentionPeriod\": 0\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}}/api/v1/app/:app_id/msg/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"application\": {\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n },\n \"channels\": [],\n \"eventId\": \"\",\n \"eventType\": \"\",\n \"payload\": {},\n \"payloadRetentionPeriod\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/msg/"
payload := strings.NewReader("{\n \"application\": {\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n },\n \"channels\": [],\n \"eventId\": \"\",\n \"eventType\": \"\",\n \"payload\": {},\n \"payloadRetentionPeriod\": 0\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/api/v1/app/:app_id/msg/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 198
{
"application": {
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
},
"channels": [],
"eventId": "",
"eventType": "",
"payload": {},
"payloadRetentionPeriod": 0
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/app/:app_id/msg/")
.setHeader("content-type", "application/json")
.setBody("{\n \"application\": {\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n },\n \"channels\": [],\n \"eventId\": \"\",\n \"eventType\": \"\",\n \"payload\": {},\n \"payloadRetentionPeriod\": 0\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/msg/"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"application\": {\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n },\n \"channels\": [],\n \"eventId\": \"\",\n \"eventType\": \"\",\n \"payload\": {},\n \"payloadRetentionPeriod\": 0\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 \"application\": {\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n },\n \"channels\": [],\n \"eventId\": \"\",\n \"eventType\": \"\",\n \"payload\": {},\n \"payloadRetentionPeriod\": 0\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/msg/")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/app/:app_id/msg/")
.header("content-type", "application/json")
.body("{\n \"application\": {\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n },\n \"channels\": [],\n \"eventId\": \"\",\n \"eventType\": \"\",\n \"payload\": {},\n \"payloadRetentionPeriod\": 0\n}")
.asString(); const data = JSON.stringify({
application: {
metadata: {},
name: '',
rateLimit: 0,
uid: ''
},
channels: [],
eventId: '',
eventType: '',
payload: {},
payloadRetentionPeriod: 0
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/api/v1/app/:app_id/msg/');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/app/:app_id/msg/',
headers: {'content-type': 'application/json'},
data: {
application: {metadata: {}, name: '', rateLimit: 0, uid: ''},
channels: [],
eventId: '',
eventType: '',
payload: {},
payloadRetentionPeriod: 0
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/msg/';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"application":{"metadata":{},"name":"","rateLimit":0,"uid":""},"channels":[],"eventId":"","eventType":"","payload":{},"payloadRetentionPeriod":0}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/msg/',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "application": {\n "metadata": {},\n "name": "",\n "rateLimit": 0,\n "uid": ""\n },\n "channels": [],\n "eventId": "",\n "eventType": "",\n "payload": {},\n "payloadRetentionPeriod": 0\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"application\": {\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n },\n \"channels\": [],\n \"eventId\": \"\",\n \"eventType\": \"\",\n \"payload\": {},\n \"payloadRetentionPeriod\": 0\n}")
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/msg/")
.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/api/v1/app/:app_id/msg/',
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({
application: {metadata: {}, name: '', rateLimit: 0, uid: ''},
channels: [],
eventId: '',
eventType: '',
payload: {},
payloadRetentionPeriod: 0
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/app/:app_id/msg/',
headers: {'content-type': 'application/json'},
body: {
application: {metadata: {}, name: '', rateLimit: 0, uid: ''},
channels: [],
eventId: '',
eventType: '',
payload: {},
payloadRetentionPeriod: 0
},
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}}/api/v1/app/:app_id/msg/');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
application: {
metadata: {},
name: '',
rateLimit: 0,
uid: ''
},
channels: [],
eventId: '',
eventType: '',
payload: {},
payloadRetentionPeriod: 0
});
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}}/api/v1/app/:app_id/msg/',
headers: {'content-type': 'application/json'},
data: {
application: {metadata: {}, name: '', rateLimit: 0, uid: ''},
channels: [],
eventId: '',
eventType: '',
payload: {},
payloadRetentionPeriod: 0
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/msg/';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"application":{"metadata":{},"name":"","rateLimit":0,"uid":""},"channels":[],"eventId":"","eventType":"","payload":{},"payloadRetentionPeriod":0}'
};
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 = @{ @"application": @{ @"metadata": @{ }, @"name": @"", @"rateLimit": @0, @"uid": @"" },
@"channels": @[ ],
@"eventId": @"",
@"eventType": @"",
@"payload": @{ },
@"payloadRetentionPeriod": @0 };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/msg/"]
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}}/api/v1/app/:app_id/msg/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"application\": {\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n },\n \"channels\": [],\n \"eventId\": \"\",\n \"eventType\": \"\",\n \"payload\": {},\n \"payloadRetentionPeriod\": 0\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/msg/",
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([
'application' => [
'metadata' => [
],
'name' => '',
'rateLimit' => 0,
'uid' => ''
],
'channels' => [
],
'eventId' => '',
'eventType' => '',
'payload' => [
],
'payloadRetentionPeriod' => 0
]),
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}}/api/v1/app/:app_id/msg/', [
'body' => '{
"application": {
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
},
"channels": [],
"eventId": "",
"eventType": "",
"payload": {},
"payloadRetentionPeriod": 0
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/msg/');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'application' => [
'metadata' => [
],
'name' => '',
'rateLimit' => 0,
'uid' => ''
],
'channels' => [
],
'eventId' => '',
'eventType' => '',
'payload' => [
],
'payloadRetentionPeriod' => 0
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'application' => [
'metadata' => [
],
'name' => '',
'rateLimit' => 0,
'uid' => ''
],
'channels' => [
],
'eventId' => '',
'eventType' => '',
'payload' => [
],
'payloadRetentionPeriod' => 0
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/msg/');
$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}}/api/v1/app/:app_id/msg/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"application": {
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
},
"channels": [],
"eventId": "",
"eventType": "",
"payload": {},
"payloadRetentionPeriod": 0
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/msg/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"application": {
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
},
"channels": [],
"eventId": "",
"eventType": "",
"payload": {},
"payloadRetentionPeriod": 0
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"application\": {\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n },\n \"channels\": [],\n \"eventId\": \"\",\n \"eventType\": \"\",\n \"payload\": {},\n \"payloadRetentionPeriod\": 0\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/api/v1/app/:app_id/msg/", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/msg/"
payload = {
"application": {
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
},
"channels": [],
"eventId": "",
"eventType": "",
"payload": {},
"payloadRetentionPeriod": 0
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/msg/"
payload <- "{\n \"application\": {\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n },\n \"channels\": [],\n \"eventId\": \"\",\n \"eventType\": \"\",\n \"payload\": {},\n \"payloadRetentionPeriod\": 0\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}}/api/v1/app/:app_id/msg/")
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 \"application\": {\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n },\n \"channels\": [],\n \"eventId\": \"\",\n \"eventType\": \"\",\n \"payload\": {},\n \"payloadRetentionPeriod\": 0\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/api/v1/app/:app_id/msg/') do |req|
req.body = "{\n \"application\": {\n \"metadata\": {},\n \"name\": \"\",\n \"rateLimit\": 0,\n \"uid\": \"\"\n },\n \"channels\": [],\n \"eventId\": \"\",\n \"eventType\": \"\",\n \"payload\": {},\n \"payloadRetentionPeriod\": 0\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/msg/";
let payload = json!({
"application": json!({
"metadata": json!({}),
"name": "",
"rateLimit": 0,
"uid": ""
}),
"channels": (),
"eventId": "",
"eventType": "",
"payload": json!({}),
"payloadRetentionPeriod": 0
});
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}}/api/v1/app/:app_id/msg/ \
--header 'content-type: application/json' \
--data '{
"application": {
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
},
"channels": [],
"eventId": "",
"eventType": "",
"payload": {},
"payloadRetentionPeriod": 0
}'echo '{
"application": {
"metadata": {},
"name": "",
"rateLimit": 0,
"uid": ""
},
"channels": [],
"eventId": "",
"eventType": "",
"payload": {},
"payloadRetentionPeriod": 0
}' | \
http POST {{baseUrl}}/api/v1/app/:app_id/msg/ \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "application": {\n "metadata": {},\n "name": "",\n "rateLimit": 0,\n "uid": ""\n },\n "channels": [],\n "eventId": "",\n "eventType": "",\n "payload": {},\n "payloadRetentionPeriod": 0\n}' \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/msg/import Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"application": [
"metadata": [],
"name": "",
"rateLimit": 0,
"uid": ""
],
"channels": [],
"eventId": "",
"eventType": "",
"payload": [],
"payloadRetentionPeriod": 0
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/msg/")! 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
{
"channels": [
"project_123",
"group_2"
],
"eventId": "evt_pNZKtWg8Azow",
"eventType": "user.signup",
"id": "msg_1srOrx2ZWZBpBUvZwXKQmoEYga2",
"payload": {
"email": "test@example.com",
"username": "test_user"
}
}
DELETE
Delete message payload
{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/
QUERY PARAMS
msg_id
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/"
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}}/api/v1/app/:app_id/msg/:msg_id/content/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/"
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/api/v1/app/:app_id/msg/:msg_id/content/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/"))
.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}}/api/v1/app/:app_id/msg/:msg_id/content/")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/")
.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}}/api/v1/app/:app_id/msg/:msg_id/content/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/';
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}}/api/v1/app/:app_id/msg/:msg_id/content/',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/msg/:msg_id/content/',
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}}/api/v1/app/:app_id/msg/:msg_id/content/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/');
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}}/api/v1/app/:app_id/msg/:msg_id/content/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/';
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}}/api/v1/app/:app_id/msg/:msg_id/content/"]
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}}/api/v1/app/:app_id/msg/:msg_id/content/" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/",
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}}/api/v1/app/:app_id/msg/:msg_id/content/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/api/v1/app/:app_id/msg/:msg_id/content/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/")
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/api/v1/app/:app_id/msg/:msg_id/content/') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/";
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}}/api/v1/app/:app_id/msg/:msg_id/content/http DELETE {{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/wget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/content/")! 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 Message
{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/
QUERY PARAMS
msg_id
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/"
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}}/api/v1/app/:app_id/msg/:msg_id/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/api/v1/app/:app_id/msg/:msg_id/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/msg/:msg_id/',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/app/:app_id/msg/:msg_id/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/api/v1/app/:app_id/msg/:msg_id/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/http GET {{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"channels": [
"project_123",
"group_2"
],
"eventId": "evt_pNZKtWg8Azow",
"eventType": "user.signup",
"id": "msg_1srOrx2ZWZBpBUvZwXKQmoEYga2",
"payload": {
"email": "test@example.com",
"username": "test_user"
}
}
GET
List Messages
{{baseUrl}}/api/v1/app/:app_id/msg/
QUERY PARAMS
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/msg/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/app/:app_id/msg/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/msg/"
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}}/api/v1/app/:app_id/msg/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/msg/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/msg/"
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/api/v1/app/:app_id/msg/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/app/:app_id/msg/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/msg/"))
.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}}/api/v1/app/:app_id/msg/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/app/:app_id/msg/")
.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}}/api/v1/app/:app_id/msg/');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/api/v1/app/:app_id/msg/'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/msg/';
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}}/api/v1/app/:app_id/msg/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/msg/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/msg/',
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}}/api/v1/app/:app_id/msg/'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/app/:app_id/msg/');
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}}/api/v1/app/:app_id/msg/'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/msg/';
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}}/api/v1/app/:app_id/msg/"]
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}}/api/v1/app/:app_id/msg/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/msg/",
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}}/api/v1/app/:app_id/msg/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/msg/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/msg/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/msg/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/msg/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/app/:app_id/msg/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/msg/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/msg/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/msg/")
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/api/v1/app/:app_id/msg/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/msg/";
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}}/api/v1/app/:app_id/msg/http GET {{baseUrl}}/api/v1/app/:app_id/msg/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/msg/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/msg/")! 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
{
"iterator": "iterator",
"prevIterator": "-iterator"
}
DELETE
Delete attempt response body
{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/
QUERY PARAMS
attempt_id
msg_id
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/"
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}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/"
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/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/"))
.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}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/")
.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}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/';
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}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/',
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}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/');
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}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/';
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}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/"]
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}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/",
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}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/")
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/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/";
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}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/http DELETE {{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/wget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/content/")! 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 Attempt
{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/
QUERY PARAMS
attempt_id
msg_id
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/"
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}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/http GET {{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/:attempt_id/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"endpointId": "ep_1srOrx2ZWZBpBUvZwXKQmoEYga2",
"id": "atmpt_1srOrx2ZWZBpBUvZwXKQmoEYga2",
"msgId": "msg_1srOrx2ZWZBpBUvZwXKQmoEYga2",
"response": "{}",
"responseStatusCode": 200,
"url": "https://example.com/webhook/"
}
GET
List Attempted Destinations
{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/
QUERY PARAMS
msg_id
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/"
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/"
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/api/v1/app/:app_id/msg/:msg_id/endpoint/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/"))
.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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/")
.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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/';
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/msg/:msg_id/endpoint/',
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/');
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/';
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/"]
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/",
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/app/:app_id/msg/:msg_id/endpoint/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/")
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/api/v1/app/:app_id/msg/:msg_id/endpoint/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/";
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/http GET {{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/")! 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
{
"iterator": "iterator"
}
GET
List Attempted Messages
{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/
QUERY PARAMS
endpoint_id
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/"
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/"
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/api/v1/app/:app_id/endpoint/:endpoint_id/msg/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/"))
.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}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/")
.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}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/';
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/msg/',
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/');
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/';
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/"]
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/",
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/app/:app_id/endpoint/:endpoint_id/msg/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/")
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/api/v1/app/:app_id/endpoint/:endpoint_id/msg/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/";
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}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/http GET {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/endpoint/:endpoint_id/msg/")! 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
{
"iterator": "iterator",
"prevIterator": "-iterator"
}
GET
List Attempts By Endpoint
{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/
QUERY PARAMS
app_id
endpoint_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/"
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}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/http GET {{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/attempt/endpoint/:endpoint_id/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"iterator": "iterator",
"prevIterator": "-iterator"
}
GET
List Attempts By Msg
{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/
QUERY PARAMS
app_id
msg_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/"
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}}/api/v1/app/:app_id/attempt/msg/:msg_id/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/api/v1/app/:app_id/attempt/msg/:msg_id/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/attempt/msg/:msg_id/',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/app/:app_id/attempt/msg/:msg_id/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/api/v1/app/:app_id/attempt/msg/:msg_id/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/http GET {{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/attempt/msg/:msg_id/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"iterator": "iterator",
"prevIterator": "-iterator"
}
GET
List Attempts For Endpoint
{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/
QUERY PARAMS
msg_id
app_id
endpoint_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/"
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/"
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/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/"))
.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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/")
.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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/';
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/',
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/');
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/';
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/"]
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/",
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/")
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/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/";
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/http GET {{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/attempt/")! 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
{
"iterator": "iterator",
"prevIterator": "-iterator"
}
GET
List Attempts
{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/
QUERY PARAMS
app_id
msg_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/"
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}}/api/v1/app/:app_id/msg/:msg_id/attempt/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/"
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/api/v1/app/:app_id/msg/:msg_id/attempt/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/"))
.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}}/api/v1/app/:app_id/msg/:msg_id/attempt/")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/")
.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}}/api/v1/app/:app_id/msg/:msg_id/attempt/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/';
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}}/api/v1/app/:app_id/msg/:msg_id/attempt/',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/msg/:msg_id/attempt/',
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}}/api/v1/app/:app_id/msg/:msg_id/attempt/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/');
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}}/api/v1/app/:app_id/msg/:msg_id/attempt/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/';
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}}/api/v1/app/:app_id/msg/:msg_id/attempt/"]
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}}/api/v1/app/:app_id/msg/:msg_id/attempt/" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/",
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}}/api/v1/app/:app_id/msg/:msg_id/attempt/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/app/:app_id/msg/:msg_id/attempt/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/")
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/api/v1/app/:app_id/msg/:msg_id/attempt/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/";
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}}/api/v1/app/:app_id/msg/:msg_id/attempt/http GET {{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/wget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/attempt/")! 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
{
"iterator": "iterator",
"prevIterator": "-iterator"
}
POST
Resend Webhook
{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/
QUERY PARAMS
endpoint_id
msg_id
app_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/")require "http/client"
url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/"
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/"
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/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/"))
.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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/")
.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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/';
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/',
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/');
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/';
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/"]
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/",
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/")
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/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/";
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}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/http POST {{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/wget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/app/:app_id/msg/:msg_id/endpoint/:endpoint_id/resend/")! 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()