Postmark API
PUT
Activate a bounce
{{baseUrl}}/bounces/:bounceid/activate
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
bounceid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bounces/:bounceid/activate");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/bounces/:bounceid/activate" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/bounces/:bounceid/activate"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/bounces/:bounceid/activate"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/bounces/:bounceid/activate");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/bounces/:bounceid/activate"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/bounces/:bounceid/activate HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/bounces/:bounceid/activate")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/bounces/:bounceid/activate"))
.header("x-postmark-server-token", "")
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/bounces/:bounceid/activate")
.put(null)
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/bounces/:bounceid/activate")
.header("x-postmark-server-token", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/bounces/:bounceid/activate');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/bounces/:bounceid/activate',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/bounces/:bounceid/activate';
const options = {method: 'PUT', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/bounces/:bounceid/activate',
method: 'PUT',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/bounces/:bounceid/activate")
.put(null)
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/bounces/:bounceid/activate',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/bounces/:bounceid/activate',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/bounces/:bounceid/activate');
req.headers({
'x-postmark-server-token': ''
});
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}}/bounces/:bounceid/activate',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/bounces/:bounceid/activate';
const options = {method: 'PUT', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/bounces/:bounceid/activate"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/bounces/:bounceid/activate" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/bounces/:bounceid/activate",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/bounces/:bounceid/activate', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/bounces/:bounceid/activate');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/bounces/:bounceid/activate');
$request->setRequestMethod('PUT');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/bounces/:bounceid/activate' -Method PUT -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/bounces/:bounceid/activate' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("PUT", "/baseUrl/bounces/:bounceid/activate", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/bounces/:bounceid/activate"
headers = {"x-postmark-server-token": ""}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/bounces/:bounceid/activate"
response <- VERB("PUT", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/bounces/:bounceid/activate")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/bounces/:bounceid/activate') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/bounces/:bounceid/activate";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/bounces/:bounceid/activate \
--header 'x-postmark-server-token: 'http PUT {{baseUrl}}/bounces/:bounceid/activate \
x-postmark-server-token:''wget --quiet \
--method PUT \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/bounces/:bounceid/activateimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bounces/:bounceid/activate")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get a single bounce
{{baseUrl}}/bounces/:bounceid
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
bounceid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bounces/:bounceid");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/bounces/:bounceid" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/bounces/:bounceid"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/bounces/:bounceid"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/bounces/:bounceid");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/bounces/:bounceid"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/bounces/:bounceid HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bounces/:bounceid")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/bounces/:bounceid"))
.header("x-postmark-server-token", "")
.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}}/bounces/:bounceid")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/bounces/:bounceid")
.header("x-postmark-server-token", "")
.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}}/bounces/:bounceid');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/bounces/:bounceid',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/bounces/:bounceid';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/bounces/:bounceid',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/bounces/:bounceid")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/bounces/:bounceid',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/bounces/:bounceid',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/bounces/:bounceid');
req.headers({
'x-postmark-server-token': ''
});
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}}/bounces/:bounceid',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/bounces/:bounceid';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/bounces/:bounceid"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/bounces/:bounceid" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/bounces/:bounceid",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/bounces/:bounceid', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/bounces/:bounceid');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/bounces/:bounceid');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/bounces/:bounceid' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/bounces/:bounceid' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/bounces/:bounceid", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/bounces/:bounceid"
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/bounces/:bounceid"
response <- VERB("GET", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/bounces/:bounceid")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/bounces/:bounceid') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/bounces/:bounceid";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/bounces/:bounceid \
--header 'x-postmark-server-token: 'http GET {{baseUrl}}/bounces/:bounceid \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/bounces/:bounceidimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bounces/:bounceid")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get bounce dump
{{baseUrl}}/bounces/:bounceid/dump
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
bounceid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bounces/:bounceid/dump");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/bounces/:bounceid/dump" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/bounces/:bounceid/dump"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/bounces/:bounceid/dump"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/bounces/:bounceid/dump");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/bounces/:bounceid/dump"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/bounces/:bounceid/dump HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bounces/:bounceid/dump")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/bounces/:bounceid/dump"))
.header("x-postmark-server-token", "")
.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}}/bounces/:bounceid/dump")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/bounces/:bounceid/dump")
.header("x-postmark-server-token", "")
.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}}/bounces/:bounceid/dump');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/bounces/:bounceid/dump',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/bounces/:bounceid/dump';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/bounces/:bounceid/dump',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/bounces/:bounceid/dump")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/bounces/:bounceid/dump',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/bounces/:bounceid/dump',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/bounces/:bounceid/dump');
req.headers({
'x-postmark-server-token': ''
});
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}}/bounces/:bounceid/dump',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/bounces/:bounceid/dump';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/bounces/:bounceid/dump"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/bounces/:bounceid/dump" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/bounces/:bounceid/dump",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/bounces/:bounceid/dump', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/bounces/:bounceid/dump');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/bounces/:bounceid/dump');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/bounces/:bounceid/dump' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/bounces/:bounceid/dump' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/bounces/:bounceid/dump", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/bounces/:bounceid/dump"
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/bounces/:bounceid/dump"
response <- VERB("GET", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/bounces/:bounceid/dump")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/bounces/:bounceid/dump') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/bounces/:bounceid/dump";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/bounces/:bounceid/dump \
--header 'x-postmark-server-token: 'http GET {{baseUrl}}/bounces/:bounceid/dump \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/bounces/:bounceid/dumpimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bounces/:bounceid/dump")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get bounces
{{baseUrl}}/bounces
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
count
offset
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bounces?count=&offset=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/bounces" {:headers {:x-postmark-server-token ""}
:query-params {:count ""
:offset ""}})require "http/client"
url = "{{baseUrl}}/bounces?count=&offset="
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/bounces?count=&offset="),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/bounces?count=&offset=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/bounces?count=&offset="
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/bounces?count=&offset= HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bounces?count=&offset=")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/bounces?count=&offset="))
.header("x-postmark-server-token", "")
.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}}/bounces?count=&offset=")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/bounces?count=&offset=")
.header("x-postmark-server-token", "")
.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}}/bounces?count=&offset=');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/bounces',
params: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/bounces?count=&offset=';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/bounces?count=&offset=',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/bounces?count=&offset=")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/bounces?count=&offset=',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/bounces',
qs: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/bounces');
req.query({
count: '',
offset: ''
});
req.headers({
'x-postmark-server-token': ''
});
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}}/bounces',
params: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/bounces?count=&offset=';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/bounces?count=&offset="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/bounces?count=&offset=" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/bounces?count=&offset=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/bounces?count=&offset=', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/bounces');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'count' => '',
'offset' => ''
]);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/bounces');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'count' => '',
'offset' => ''
]));
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/bounces?count=&offset=' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/bounces?count=&offset=' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/bounces?count=&offset=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/bounces"
querystring = {"count":"","offset":""}
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/bounces"
queryString <- list(
count = "",
offset = ""
)
response <- VERB("GET", url, query = queryString, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/bounces?count=&offset=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/bounces') do |req|
req.headers['x-postmark-server-token'] = ''
req.params['count'] = ''
req.params['offset'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/bounces";
let querystring = [
("count", ""),
("offset", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/bounces?count=&offset=' \
--header 'x-postmark-server-token: 'http GET '{{baseUrl}}/bounces?count=&offset=' \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- '{{baseUrl}}/bounces?count=&offset='import Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bounces?count=&offset=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get delivery stats
{{baseUrl}}/deliverystats
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/deliverystats");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/deliverystats" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/deliverystats"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/deliverystats"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/deliverystats");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/deliverystats"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/deliverystats HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/deliverystats")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/deliverystats"))
.header("x-postmark-server-token", "")
.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}}/deliverystats")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/deliverystats")
.header("x-postmark-server-token", "")
.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}}/deliverystats');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/deliverystats',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/deliverystats';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/deliverystats',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/deliverystats")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/deliverystats',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/deliverystats',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/deliverystats');
req.headers({
'x-postmark-server-token': ''
});
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}}/deliverystats',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/deliverystats';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/deliverystats"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/deliverystats" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/deliverystats",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/deliverystats', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/deliverystats');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/deliverystats');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/deliverystats' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/deliverystats' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/deliverystats", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/deliverystats"
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/deliverystats"
response <- VERB("GET", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/deliverystats")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/deliverystats') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/deliverystats";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/deliverystats \
--header 'x-postmark-server-token: 'http GET {{baseUrl}}/deliverystats \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/deliverystatsimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/deliverystats")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create an inbound rule trigger
{{baseUrl}}/triggers/inboundrules
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/triggers/inboundrules");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/triggers/inboundrules" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/triggers/inboundrules"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/triggers/inboundrules"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/triggers/inboundrules");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/triggers/inboundrules"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/triggers/inboundrules HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/triggers/inboundrules")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/triggers/inboundrules"))
.header("x-postmark-server-token", "")
.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}}/triggers/inboundrules")
.post(null)
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/triggers/inboundrules")
.header("x-postmark-server-token", "")
.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}}/triggers/inboundrules');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/triggers/inboundrules',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/triggers/inboundrules';
const options = {method: 'POST', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/triggers/inboundrules',
method: 'POST',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/triggers/inboundrules")
.post(null)
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/triggers/inboundrules',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/triggers/inboundrules',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/triggers/inboundrules');
req.headers({
'x-postmark-server-token': ''
});
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}}/triggers/inboundrules',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/triggers/inboundrules';
const options = {method: 'POST', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/triggers/inboundrules"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/triggers/inboundrules" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/triggers/inboundrules",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/triggers/inboundrules', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/triggers/inboundrules');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/triggers/inboundrules');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/triggers/inboundrules' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/triggers/inboundrules' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("POST", "/baseUrl/triggers/inboundrules", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/triggers/inboundrules"
headers = {"x-postmark-server-token": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/triggers/inboundrules"
response <- VERB("POST", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/triggers/inboundrules")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/triggers/inboundrules') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/triggers/inboundrules";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/triggers/inboundrules \
--header 'x-postmark-server-token: 'http POST {{baseUrl}}/triggers/inboundrules \
x-postmark-server-token:''wget --quiet \
--method POST \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/triggers/inboundrulesimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/triggers/inboundrules")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete a single trigger
{{baseUrl}}/triggers/inboundrules/:triggerid
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
triggerid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/triggers/inboundrules/:triggerid");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/triggers/inboundrules/:triggerid" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/triggers/inboundrules/:triggerid"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/triggers/inboundrules/:triggerid"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/triggers/inboundrules/:triggerid");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/triggers/inboundrules/:triggerid"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/triggers/inboundrules/:triggerid HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/triggers/inboundrules/:triggerid")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/triggers/inboundrules/:triggerid"))
.header("x-postmark-server-token", "")
.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}}/triggers/inboundrules/:triggerid")
.delete(null)
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/triggers/inboundrules/:triggerid")
.header("x-postmark-server-token", "")
.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}}/triggers/inboundrules/:triggerid');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/triggers/inboundrules/:triggerid',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/triggers/inboundrules/:triggerid';
const options = {method: 'DELETE', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/triggers/inboundrules/:triggerid',
method: 'DELETE',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/triggers/inboundrules/:triggerid")
.delete(null)
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/triggers/inboundrules/:triggerid',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/triggers/inboundrules/:triggerid',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/triggers/inboundrules/:triggerid');
req.headers({
'x-postmark-server-token': ''
});
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}}/triggers/inboundrules/:triggerid',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/triggers/inboundrules/:triggerid';
const options = {method: 'DELETE', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/triggers/inboundrules/:triggerid"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/triggers/inboundrules/:triggerid" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/triggers/inboundrules/:triggerid",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/triggers/inboundrules/:triggerid', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/triggers/inboundrules/:triggerid');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/triggers/inboundrules/:triggerid');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/triggers/inboundrules/:triggerid' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/triggers/inboundrules/:triggerid' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("DELETE", "/baseUrl/triggers/inboundrules/:triggerid", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/triggers/inboundrules/:triggerid"
headers = {"x-postmark-server-token": ""}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/triggers/inboundrules/:triggerid"
response <- VERB("DELETE", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/triggers/inboundrules/:triggerid")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/triggers/inboundrules/:triggerid') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/triggers/inboundrules/:triggerid";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/triggers/inboundrules/:triggerid \
--header 'x-postmark-server-token: 'http DELETE {{baseUrl}}/triggers/inboundrules/:triggerid \
x-postmark-server-token:''wget --quiet \
--method DELETE \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/triggers/inboundrules/:triggeridimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/triggers/inboundrules/:triggerid")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List inbound rule triggers
{{baseUrl}}/triggers/inboundrules
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
count
offset
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/triggers/inboundrules?count=&offset=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/triggers/inboundrules" {:headers {:x-postmark-server-token ""}
:query-params {:count ""
:offset ""}})require "http/client"
url = "{{baseUrl}}/triggers/inboundrules?count=&offset="
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/triggers/inboundrules?count=&offset="),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/triggers/inboundrules?count=&offset=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/triggers/inboundrules?count=&offset="
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/triggers/inboundrules?count=&offset= HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/triggers/inboundrules?count=&offset=")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/triggers/inboundrules?count=&offset="))
.header("x-postmark-server-token", "")
.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}}/triggers/inboundrules?count=&offset=")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/triggers/inboundrules?count=&offset=")
.header("x-postmark-server-token", "")
.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}}/triggers/inboundrules?count=&offset=');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/triggers/inboundrules',
params: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/triggers/inboundrules?count=&offset=';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/triggers/inboundrules?count=&offset=',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/triggers/inboundrules?count=&offset=")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/triggers/inboundrules?count=&offset=',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/triggers/inboundrules',
qs: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/triggers/inboundrules');
req.query({
count: '',
offset: ''
});
req.headers({
'x-postmark-server-token': ''
});
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}}/triggers/inboundrules',
params: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/triggers/inboundrules?count=&offset=';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/triggers/inboundrules?count=&offset="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/triggers/inboundrules?count=&offset=" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/triggers/inboundrules?count=&offset=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/triggers/inboundrules?count=&offset=', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/triggers/inboundrules');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'count' => '',
'offset' => ''
]);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/triggers/inboundrules');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'count' => '',
'offset' => ''
]));
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/triggers/inboundrules?count=&offset=' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/triggers/inboundrules?count=&offset=' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/triggers/inboundrules?count=&offset=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/triggers/inboundrules"
querystring = {"count":"","offset":""}
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/triggers/inboundrules"
queryString <- list(
count = "",
offset = ""
)
response <- VERB("GET", url, query = queryString, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/triggers/inboundrules?count=&offset=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/triggers/inboundrules') do |req|
req.headers['x-postmark-server-token'] = ''
req.params['count'] = ''
req.params['offset'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/triggers/inboundrules";
let querystring = [
("count", ""),
("offset", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/triggers/inboundrules?count=&offset=' \
--header 'x-postmark-server-token: 'http GET '{{baseUrl}}/triggers/inboundrules?count=&offset=' \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- '{{baseUrl}}/triggers/inboundrules?count=&offset='import Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/triggers/inboundrules?count=&offset=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Bypass rules for a blocked inbound message
{{baseUrl}}/messages/inbound/:messageid/bypass
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
messageid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messages/inbound/:messageid/bypass");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/messages/inbound/:messageid/bypass" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/messages/inbound/:messageid/bypass"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/messages/inbound/:messageid/bypass"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/messages/inbound/:messageid/bypass");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/messages/inbound/:messageid/bypass"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/messages/inbound/:messageid/bypass HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/messages/inbound/:messageid/bypass")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/messages/inbound/:messageid/bypass"))
.header("x-postmark-server-token", "")
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/messages/inbound/:messageid/bypass")
.put(null)
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/messages/inbound/:messageid/bypass")
.header("x-postmark-server-token", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/messages/inbound/:messageid/bypass');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/messages/inbound/:messageid/bypass',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/messages/inbound/:messageid/bypass';
const options = {method: 'PUT', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/messages/inbound/:messageid/bypass',
method: 'PUT',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/messages/inbound/:messageid/bypass")
.put(null)
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/messages/inbound/:messageid/bypass',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/messages/inbound/:messageid/bypass',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/messages/inbound/:messageid/bypass');
req.headers({
'x-postmark-server-token': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/messages/inbound/:messageid/bypass',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/messages/inbound/:messageid/bypass';
const options = {method: 'PUT', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/messages/inbound/:messageid/bypass"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/messages/inbound/:messageid/bypass" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/messages/inbound/:messageid/bypass",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/messages/inbound/:messageid/bypass', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/messages/inbound/:messageid/bypass');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/messages/inbound/:messageid/bypass');
$request->setRequestMethod('PUT');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/messages/inbound/:messageid/bypass' -Method PUT -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/messages/inbound/:messageid/bypass' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("PUT", "/baseUrl/messages/inbound/:messageid/bypass", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/messages/inbound/:messageid/bypass"
headers = {"x-postmark-server-token": ""}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/messages/inbound/:messageid/bypass"
response <- VERB("PUT", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/messages/inbound/:messageid/bypass")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/messages/inbound/:messageid/bypass') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/messages/inbound/:messageid/bypass";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/messages/inbound/:messageid/bypass \
--header 'x-postmark-server-token: 'http PUT {{baseUrl}}/messages/inbound/:messageid/bypass \
x-postmark-server-token:''wget --quiet \
--method PUT \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/messages/inbound/:messageid/bypassimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messages/inbound/:messageid/bypass")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Clicks for a all messages
{{baseUrl}}/messages/outbound/clicks
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
count
offset
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messages/outbound/clicks?count=&offset=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/messages/outbound/clicks" {:headers {:x-postmark-server-token ""}
:query-params {:count ""
:offset ""}})require "http/client"
url = "{{baseUrl}}/messages/outbound/clicks?count=&offset="
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/messages/outbound/clicks?count=&offset="),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/messages/outbound/clicks?count=&offset=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/messages/outbound/clicks?count=&offset="
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/messages/outbound/clicks?count=&offset= HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/messages/outbound/clicks?count=&offset=")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/messages/outbound/clicks?count=&offset="))
.header("x-postmark-server-token", "")
.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}}/messages/outbound/clicks?count=&offset=")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/messages/outbound/clicks?count=&offset=")
.header("x-postmark-server-token", "")
.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}}/messages/outbound/clicks?count=&offset=');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/messages/outbound/clicks',
params: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/messages/outbound/clicks?count=&offset=';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/messages/outbound/clicks?count=&offset=',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/messages/outbound/clicks?count=&offset=")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/messages/outbound/clicks?count=&offset=',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/messages/outbound/clicks',
qs: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/messages/outbound/clicks');
req.query({
count: '',
offset: ''
});
req.headers({
'x-postmark-server-token': ''
});
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}}/messages/outbound/clicks',
params: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/messages/outbound/clicks?count=&offset=';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/messages/outbound/clicks?count=&offset="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/messages/outbound/clicks?count=&offset=" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/messages/outbound/clicks?count=&offset=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/messages/outbound/clicks?count=&offset=', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/messages/outbound/clicks');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'count' => '',
'offset' => ''
]);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/messages/outbound/clicks');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'count' => '',
'offset' => ''
]));
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/messages/outbound/clicks?count=&offset=' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/messages/outbound/clicks?count=&offset=' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/messages/outbound/clicks?count=&offset=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/messages/outbound/clicks"
querystring = {"count":"","offset":""}
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/messages/outbound/clicks"
queryString <- list(
count = "",
offset = ""
)
response <- VERB("GET", url, query = queryString, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/messages/outbound/clicks?count=&offset=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/messages/outbound/clicks') do |req|
req.headers['x-postmark-server-token'] = ''
req.params['count'] = ''
req.params['offset'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/messages/outbound/clicks";
let querystring = [
("count", ""),
("offset", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/messages/outbound/clicks?count=&offset=' \
--header 'x-postmark-server-token: 'http GET '{{baseUrl}}/messages/outbound/clicks?count=&offset=' \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- '{{baseUrl}}/messages/outbound/clicks?count=&offset='import Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messages/outbound/clicks?count=&offset=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Inbound message details
{{baseUrl}}/messages/inbound/:messageid/details
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
messageid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messages/inbound/:messageid/details");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/messages/inbound/:messageid/details" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/messages/inbound/:messageid/details"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/messages/inbound/:messageid/details"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/messages/inbound/:messageid/details");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/messages/inbound/:messageid/details"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/messages/inbound/:messageid/details HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/messages/inbound/:messageid/details")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/messages/inbound/:messageid/details"))
.header("x-postmark-server-token", "")
.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}}/messages/inbound/:messageid/details")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/messages/inbound/:messageid/details")
.header("x-postmark-server-token", "")
.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}}/messages/inbound/:messageid/details');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/messages/inbound/:messageid/details',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/messages/inbound/:messageid/details';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/messages/inbound/:messageid/details',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/messages/inbound/:messageid/details")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/messages/inbound/:messageid/details',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/messages/inbound/:messageid/details',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/messages/inbound/:messageid/details');
req.headers({
'x-postmark-server-token': ''
});
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}}/messages/inbound/:messageid/details',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/messages/inbound/:messageid/details';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/messages/inbound/:messageid/details"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/messages/inbound/:messageid/details" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/messages/inbound/:messageid/details",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/messages/inbound/:messageid/details', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/messages/inbound/:messageid/details');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/messages/inbound/:messageid/details');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/messages/inbound/:messageid/details' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/messages/inbound/:messageid/details' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/messages/inbound/:messageid/details", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/messages/inbound/:messageid/details"
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/messages/inbound/:messageid/details"
response <- VERB("GET", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/messages/inbound/:messageid/details")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/messages/inbound/:messageid/details') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/messages/inbound/:messageid/details";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/messages/inbound/:messageid/details \
--header 'x-postmark-server-token: 'http GET {{baseUrl}}/messages/inbound/:messageid/details \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/messages/inbound/:messageid/detailsimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messages/inbound/:messageid/details")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Inbound message search
{{baseUrl}}/messages/inbound
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
count
offset
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messages/inbound?count=&offset=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/messages/inbound" {:headers {:x-postmark-server-token ""}
:query-params {:count ""
:offset ""}})require "http/client"
url = "{{baseUrl}}/messages/inbound?count=&offset="
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/messages/inbound?count=&offset="),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/messages/inbound?count=&offset=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/messages/inbound?count=&offset="
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/messages/inbound?count=&offset= HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/messages/inbound?count=&offset=")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/messages/inbound?count=&offset="))
.header("x-postmark-server-token", "")
.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}}/messages/inbound?count=&offset=")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/messages/inbound?count=&offset=")
.header("x-postmark-server-token", "")
.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}}/messages/inbound?count=&offset=');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/messages/inbound',
params: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/messages/inbound?count=&offset=';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/messages/inbound?count=&offset=',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/messages/inbound?count=&offset=")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/messages/inbound?count=&offset=',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/messages/inbound',
qs: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/messages/inbound');
req.query({
count: '',
offset: ''
});
req.headers({
'x-postmark-server-token': ''
});
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}}/messages/inbound',
params: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/messages/inbound?count=&offset=';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/messages/inbound?count=&offset="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/messages/inbound?count=&offset=" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/messages/inbound?count=&offset=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/messages/inbound?count=&offset=', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/messages/inbound');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'count' => '',
'offset' => ''
]);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/messages/inbound');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'count' => '',
'offset' => ''
]));
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/messages/inbound?count=&offset=' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/messages/inbound?count=&offset=' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/messages/inbound?count=&offset=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/messages/inbound"
querystring = {"count":"","offset":""}
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/messages/inbound"
queryString <- list(
count = "",
offset = ""
)
response <- VERB("GET", url, query = queryString, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/messages/inbound?count=&offset=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/messages/inbound') do |req|
req.headers['x-postmark-server-token'] = ''
req.params['count'] = ''
req.params['offset'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/messages/inbound";
let querystring = [
("count", ""),
("offset", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/messages/inbound?count=&offset=' \
--header 'x-postmark-server-token: 'http GET '{{baseUrl}}/messages/inbound?count=&offset=' \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- '{{baseUrl}}/messages/inbound?count=&offset='import Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messages/inbound?count=&offset=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Opens for all messages
{{baseUrl}}/messages/outbound/opens
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
count
offset
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messages/outbound/opens?count=&offset=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/messages/outbound/opens" {:headers {:x-postmark-server-token ""}
:query-params {:count ""
:offset ""}})require "http/client"
url = "{{baseUrl}}/messages/outbound/opens?count=&offset="
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/messages/outbound/opens?count=&offset="),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/messages/outbound/opens?count=&offset=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/messages/outbound/opens?count=&offset="
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/messages/outbound/opens?count=&offset= HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/messages/outbound/opens?count=&offset=")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/messages/outbound/opens?count=&offset="))
.header("x-postmark-server-token", "")
.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}}/messages/outbound/opens?count=&offset=")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/messages/outbound/opens?count=&offset=")
.header("x-postmark-server-token", "")
.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}}/messages/outbound/opens?count=&offset=');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/messages/outbound/opens',
params: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/messages/outbound/opens?count=&offset=';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/messages/outbound/opens?count=&offset=',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/messages/outbound/opens?count=&offset=")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/messages/outbound/opens?count=&offset=',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/messages/outbound/opens',
qs: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/messages/outbound/opens');
req.query({
count: '',
offset: ''
});
req.headers({
'x-postmark-server-token': ''
});
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}}/messages/outbound/opens',
params: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/messages/outbound/opens?count=&offset=';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/messages/outbound/opens?count=&offset="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/messages/outbound/opens?count=&offset=" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/messages/outbound/opens?count=&offset=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/messages/outbound/opens?count=&offset=', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/messages/outbound/opens');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'count' => '',
'offset' => ''
]);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/messages/outbound/opens');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'count' => '',
'offset' => ''
]));
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/messages/outbound/opens?count=&offset=' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/messages/outbound/opens?count=&offset=' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/messages/outbound/opens?count=&offset=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/messages/outbound/opens"
querystring = {"count":"","offset":""}
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/messages/outbound/opens"
queryString <- list(
count = "",
offset = ""
)
response <- VERB("GET", url, query = queryString, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/messages/outbound/opens?count=&offset=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/messages/outbound/opens') do |req|
req.headers['x-postmark-server-token'] = ''
req.params['count'] = ''
req.params['offset'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/messages/outbound/opens";
let querystring = [
("count", ""),
("offset", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/messages/outbound/opens?count=&offset=' \
--header 'x-postmark-server-token: 'http GET '{{baseUrl}}/messages/outbound/opens?count=&offset=' \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- '{{baseUrl}}/messages/outbound/opens?count=&offset='import Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messages/outbound/opens?count=&offset=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Outbound message details
{{baseUrl}}/messages/outbound/:messageid/details
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
messageid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messages/outbound/:messageid/details");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/messages/outbound/:messageid/details" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/messages/outbound/:messageid/details"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/messages/outbound/:messageid/details"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/messages/outbound/:messageid/details");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/messages/outbound/:messageid/details"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/messages/outbound/:messageid/details HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/messages/outbound/:messageid/details")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/messages/outbound/:messageid/details"))
.header("x-postmark-server-token", "")
.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}}/messages/outbound/:messageid/details")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/messages/outbound/:messageid/details")
.header("x-postmark-server-token", "")
.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}}/messages/outbound/:messageid/details');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/messages/outbound/:messageid/details',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/messages/outbound/:messageid/details';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/messages/outbound/:messageid/details',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/messages/outbound/:messageid/details")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/messages/outbound/:messageid/details',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/messages/outbound/:messageid/details',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/messages/outbound/:messageid/details');
req.headers({
'x-postmark-server-token': ''
});
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}}/messages/outbound/:messageid/details',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/messages/outbound/:messageid/details';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/messages/outbound/:messageid/details"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/messages/outbound/:messageid/details" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/messages/outbound/:messageid/details",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/messages/outbound/:messageid/details', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/messages/outbound/:messageid/details');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/messages/outbound/:messageid/details');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/messages/outbound/:messageid/details' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/messages/outbound/:messageid/details' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/messages/outbound/:messageid/details", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/messages/outbound/:messageid/details"
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/messages/outbound/:messageid/details"
response <- VERB("GET", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/messages/outbound/:messageid/details")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/messages/outbound/:messageid/details') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/messages/outbound/:messageid/details";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/messages/outbound/:messageid/details \
--header 'x-postmark-server-token: 'http GET {{baseUrl}}/messages/outbound/:messageid/details \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/messages/outbound/:messageid/detailsimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messages/outbound/:messageid/details")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Outbound message dump
{{baseUrl}}/messages/outbound/:messageid/dump
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
messageid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messages/outbound/:messageid/dump");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/messages/outbound/:messageid/dump" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/messages/outbound/:messageid/dump"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/messages/outbound/:messageid/dump"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/messages/outbound/:messageid/dump");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/messages/outbound/:messageid/dump"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/messages/outbound/:messageid/dump HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/messages/outbound/:messageid/dump")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/messages/outbound/:messageid/dump"))
.header("x-postmark-server-token", "")
.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}}/messages/outbound/:messageid/dump")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/messages/outbound/:messageid/dump")
.header("x-postmark-server-token", "")
.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}}/messages/outbound/:messageid/dump');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/messages/outbound/:messageid/dump',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/messages/outbound/:messageid/dump';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/messages/outbound/:messageid/dump',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/messages/outbound/:messageid/dump")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/messages/outbound/:messageid/dump',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/messages/outbound/:messageid/dump',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/messages/outbound/:messageid/dump');
req.headers({
'x-postmark-server-token': ''
});
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}}/messages/outbound/:messageid/dump',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/messages/outbound/:messageid/dump';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/messages/outbound/:messageid/dump"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/messages/outbound/:messageid/dump" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/messages/outbound/:messageid/dump",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/messages/outbound/:messageid/dump', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/messages/outbound/:messageid/dump');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/messages/outbound/:messageid/dump');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/messages/outbound/:messageid/dump' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/messages/outbound/:messageid/dump' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/messages/outbound/:messageid/dump", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/messages/outbound/:messageid/dump"
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/messages/outbound/:messageid/dump"
response <- VERB("GET", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/messages/outbound/:messageid/dump")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/messages/outbound/:messageid/dump') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/messages/outbound/:messageid/dump";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/messages/outbound/:messageid/dump \
--header 'x-postmark-server-token: 'http GET {{baseUrl}}/messages/outbound/:messageid/dump \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/messages/outbound/:messageid/dumpimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messages/outbound/:messageid/dump")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Outbound message search
{{baseUrl}}/messages/outbound
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
count
offset
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messages/outbound?count=&offset=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/messages/outbound" {:headers {:x-postmark-server-token ""}
:query-params {:count ""
:offset ""}})require "http/client"
url = "{{baseUrl}}/messages/outbound?count=&offset="
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/messages/outbound?count=&offset="),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/messages/outbound?count=&offset=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/messages/outbound?count=&offset="
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/messages/outbound?count=&offset= HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/messages/outbound?count=&offset=")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/messages/outbound?count=&offset="))
.header("x-postmark-server-token", "")
.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}}/messages/outbound?count=&offset=")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/messages/outbound?count=&offset=")
.header("x-postmark-server-token", "")
.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}}/messages/outbound?count=&offset=');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/messages/outbound',
params: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/messages/outbound?count=&offset=';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/messages/outbound?count=&offset=',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/messages/outbound?count=&offset=")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/messages/outbound?count=&offset=',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/messages/outbound',
qs: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/messages/outbound');
req.query({
count: '',
offset: ''
});
req.headers({
'x-postmark-server-token': ''
});
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}}/messages/outbound',
params: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/messages/outbound?count=&offset=';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/messages/outbound?count=&offset="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/messages/outbound?count=&offset=" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/messages/outbound?count=&offset=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/messages/outbound?count=&offset=', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/messages/outbound');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'count' => '',
'offset' => ''
]);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/messages/outbound');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'count' => '',
'offset' => ''
]));
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/messages/outbound?count=&offset=' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/messages/outbound?count=&offset=' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/messages/outbound?count=&offset=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/messages/outbound"
querystring = {"count":"","offset":""}
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/messages/outbound"
queryString <- list(
count = "",
offset = ""
)
response <- VERB("GET", url, query = queryString, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/messages/outbound?count=&offset=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/messages/outbound') do |req|
req.headers['x-postmark-server-token'] = ''
req.params['count'] = ''
req.params['offset'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/messages/outbound";
let querystring = [
("count", ""),
("offset", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/messages/outbound?count=&offset=' \
--header 'x-postmark-server-token: 'http GET '{{baseUrl}}/messages/outbound?count=&offset=' \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- '{{baseUrl}}/messages/outbound?count=&offset='import Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messages/outbound?count=&offset=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve Message Clicks
{{baseUrl}}/messages/outbound/clicks/:messageid
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
count
offset
messageid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/messages/outbound/clicks/:messageid" {:headers {:x-postmark-server-token ""}
:query-params {:count ""
:offset ""}})require "http/client"
url = "{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset="
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset="),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset="
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/messages/outbound/clicks/:messageid?count=&offset= HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset=")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset="))
.header("x-postmark-server-token", "")
.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}}/messages/outbound/clicks/:messageid?count=&offset=")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset=")
.header("x-postmark-server-token", "")
.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}}/messages/outbound/clicks/:messageid?count=&offset=');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/messages/outbound/clicks/:messageid',
params: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset=';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset=',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset=")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/messages/outbound/clicks/:messageid?count=&offset=',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/messages/outbound/clicks/:messageid',
qs: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/messages/outbound/clicks/:messageid');
req.query({
count: '',
offset: ''
});
req.headers({
'x-postmark-server-token': ''
});
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}}/messages/outbound/clicks/:messageid',
params: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset=';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset=" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset=', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/messages/outbound/clicks/:messageid');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'count' => '',
'offset' => ''
]);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/messages/outbound/clicks/:messageid');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'count' => '',
'offset' => ''
]));
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset=' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset=' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/messages/outbound/clicks/:messageid?count=&offset=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/messages/outbound/clicks/:messageid"
querystring = {"count":"","offset":""}
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/messages/outbound/clicks/:messageid"
queryString <- list(
count = "",
offset = ""
)
response <- VERB("GET", url, query = queryString, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/messages/outbound/clicks/:messageid') do |req|
req.headers['x-postmark-server-token'] = ''
req.params['count'] = ''
req.params['offset'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/messages/outbound/clicks/:messageid";
let querystring = [
("count", ""),
("offset", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset=' \
--header 'x-postmark-server-token: 'http GET '{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset=' \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- '{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset='import Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messages/outbound/clicks/:messageid?count=&offset=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve Message Opens
{{baseUrl}}/messages/outbound/opens/:messageid
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
count
offset
messageid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/messages/outbound/opens/:messageid" {:headers {:x-postmark-server-token ""}
:query-params {:count ""
:offset ""}})require "http/client"
url = "{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset="
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset="),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset="
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/messages/outbound/opens/:messageid?count=&offset= HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset=")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset="))
.header("x-postmark-server-token", "")
.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}}/messages/outbound/opens/:messageid?count=&offset=")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset=")
.header("x-postmark-server-token", "")
.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}}/messages/outbound/opens/:messageid?count=&offset=');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/messages/outbound/opens/:messageid',
params: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset=';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset=',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset=")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/messages/outbound/opens/:messageid?count=&offset=',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/messages/outbound/opens/:messageid',
qs: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/messages/outbound/opens/:messageid');
req.query({
count: '',
offset: ''
});
req.headers({
'x-postmark-server-token': ''
});
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}}/messages/outbound/opens/:messageid',
params: {count: '', offset: ''},
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset=';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset=" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset=', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/messages/outbound/opens/:messageid');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'count' => '',
'offset' => ''
]);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/messages/outbound/opens/:messageid');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'count' => '',
'offset' => ''
]));
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset=' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset=' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/messages/outbound/opens/:messageid?count=&offset=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/messages/outbound/opens/:messageid"
querystring = {"count":"","offset":""}
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/messages/outbound/opens/:messageid"
queryString <- list(
count = "",
offset = ""
)
response <- VERB("GET", url, query = queryString, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/messages/outbound/opens/:messageid') do |req|
req.headers['x-postmark-server-token'] = ''
req.params['count'] = ''
req.params['offset'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/messages/outbound/opens/:messageid";
let querystring = [
("count", ""),
("offset", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset=' \
--header 'x-postmark-server-token: 'http GET '{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset=' \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- '{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset='import Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messages/outbound/opens/:messageid?count=&offset=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Retry a failed inbound message for processing
{{baseUrl}}/messages/inbound/:messageid/retry
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
messageid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messages/inbound/:messageid/retry");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/messages/inbound/:messageid/retry" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/messages/inbound/:messageid/retry"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/messages/inbound/:messageid/retry"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/messages/inbound/:messageid/retry");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/messages/inbound/:messageid/retry"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/messages/inbound/:messageid/retry HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/messages/inbound/:messageid/retry")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/messages/inbound/:messageid/retry"))
.header("x-postmark-server-token", "")
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/messages/inbound/:messageid/retry")
.put(null)
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/messages/inbound/:messageid/retry")
.header("x-postmark-server-token", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/messages/inbound/:messageid/retry');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/messages/inbound/:messageid/retry',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/messages/inbound/:messageid/retry';
const options = {method: 'PUT', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/messages/inbound/:messageid/retry',
method: 'PUT',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/messages/inbound/:messageid/retry")
.put(null)
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/messages/inbound/:messageid/retry',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/messages/inbound/:messageid/retry',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/messages/inbound/:messageid/retry');
req.headers({
'x-postmark-server-token': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/messages/inbound/:messageid/retry',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/messages/inbound/:messageid/retry';
const options = {method: 'PUT', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/messages/inbound/:messageid/retry"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/messages/inbound/:messageid/retry" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/messages/inbound/:messageid/retry",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/messages/inbound/:messageid/retry', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/messages/inbound/:messageid/retry');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/messages/inbound/:messageid/retry');
$request->setRequestMethod('PUT');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/messages/inbound/:messageid/retry' -Method PUT -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/messages/inbound/:messageid/retry' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("PUT", "/baseUrl/messages/inbound/:messageid/retry", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/messages/inbound/:messageid/retry"
headers = {"x-postmark-server-token": ""}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/messages/inbound/:messageid/retry"
response <- VERB("PUT", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/messages/inbound/:messageid/retry")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/messages/inbound/:messageid/retry') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/messages/inbound/:messageid/retry";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/messages/inbound/:messageid/retry \
--header 'x-postmark-server-token: 'http PUT {{baseUrl}}/messages/inbound/:messageid/retry \
x-postmark-server-token:''wget --quiet \
--method PUT \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/messages/inbound/:messageid/retryimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messages/inbound/:messageid/retry")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Send a batch of email using templates.
{{baseUrl}}/email/batchWithTemplates
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/email/batchWithTemplates");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/email/batchWithTemplates" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/email/batchWithTemplates"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/email/batchWithTemplates"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/email/batchWithTemplates");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/email/batchWithTemplates"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/email/batchWithTemplates HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/email/batchWithTemplates")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/email/batchWithTemplates"))
.header("x-postmark-server-token", "")
.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}}/email/batchWithTemplates")
.post(null)
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/email/batchWithTemplates")
.header("x-postmark-server-token", "")
.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}}/email/batchWithTemplates');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/email/batchWithTemplates',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/email/batchWithTemplates';
const options = {method: 'POST', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/email/batchWithTemplates',
method: 'POST',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/email/batchWithTemplates")
.post(null)
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/email/batchWithTemplates',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/email/batchWithTemplates',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/email/batchWithTemplates');
req.headers({
'x-postmark-server-token': ''
});
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}}/email/batchWithTemplates',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/email/batchWithTemplates';
const options = {method: 'POST', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/email/batchWithTemplates"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/email/batchWithTemplates" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/email/batchWithTemplates",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/email/batchWithTemplates', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/email/batchWithTemplates');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/email/batchWithTemplates');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/email/batchWithTemplates' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/email/batchWithTemplates' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("POST", "/baseUrl/email/batchWithTemplates", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/email/batchWithTemplates"
headers = {"x-postmark-server-token": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/email/batchWithTemplates"
response <- VERB("POST", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/email/batchWithTemplates")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/email/batchWithTemplates') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/email/batchWithTemplates";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/email/batchWithTemplates \
--header 'x-postmark-server-token: 'http POST {{baseUrl}}/email/batchWithTemplates \
x-postmark-server-token:''wget --quiet \
--method POST \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/email/batchWithTemplatesimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/email/batchWithTemplates")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Send a batch of emails
{{baseUrl}}/email/batch
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/email/batch");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/email/batch" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/email/batch"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/email/batch"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/email/batch");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/email/batch"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/email/batch HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/email/batch")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/email/batch"))
.header("x-postmark-server-token", "")
.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}}/email/batch")
.post(null)
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/email/batch")
.header("x-postmark-server-token", "")
.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}}/email/batch');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/email/batch',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/email/batch';
const options = {method: 'POST', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/email/batch',
method: 'POST',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/email/batch")
.post(null)
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/email/batch',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/email/batch',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/email/batch');
req.headers({
'x-postmark-server-token': ''
});
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}}/email/batch',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/email/batch';
const options = {method: 'POST', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/email/batch"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/email/batch" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/email/batch",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/email/batch', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/email/batch');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/email/batch');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/email/batch' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/email/batch' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("POST", "/baseUrl/email/batch", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/email/batch"
headers = {"x-postmark-server-token": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/email/batch"
response <- VERB("POST", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/email/batch")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/email/batch') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/email/batch";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/email/batch \
--header 'x-postmark-server-token: 'http POST {{baseUrl}}/email/batch \
x-postmark-server-token:''wget --quiet \
--method POST \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/email/batchimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/email/batch")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Send a single email
{{baseUrl}}/email
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/email");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/email" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/email"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/email"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/email");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/email"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/email HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/email")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/email"))
.header("x-postmark-server-token", "")
.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}}/email")
.post(null)
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/email")
.header("x-postmark-server-token", "")
.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}}/email');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/email',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/email';
const options = {method: 'POST', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/email',
method: 'POST',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/email")
.post(null)
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/email',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/email',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/email');
req.headers({
'x-postmark-server-token': ''
});
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}}/email',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/email';
const options = {method: 'POST', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/email"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/email" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/email",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/email', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/email');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/email');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/email' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/email' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("POST", "/baseUrl/email", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/email"
headers = {"x-postmark-server-token": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/email"
response <- VERB("POST", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/email")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/email') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/email";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/email \
--header 'x-postmark-server-token: 'http POST {{baseUrl}}/email \
x-postmark-server-token:''wget --quiet \
--method POST \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/emailimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/email")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Send an email using a Template
{{baseUrl}}/email/withTemplate
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/email/withTemplate");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/email/withTemplate" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/email/withTemplate"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/email/withTemplate"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/email/withTemplate");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/email/withTemplate"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/email/withTemplate HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/email/withTemplate")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/email/withTemplate"))
.header("x-postmark-server-token", "")
.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}}/email/withTemplate")
.post(null)
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/email/withTemplate")
.header("x-postmark-server-token", "")
.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}}/email/withTemplate');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/email/withTemplate',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/email/withTemplate';
const options = {method: 'POST', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/email/withTemplate',
method: 'POST',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/email/withTemplate")
.post(null)
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/email/withTemplate',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/email/withTemplate',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/email/withTemplate');
req.headers({
'x-postmark-server-token': ''
});
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}}/email/withTemplate',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/email/withTemplate';
const options = {method: 'POST', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/email/withTemplate"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/email/withTemplate" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/email/withTemplate",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/email/withTemplate', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/email/withTemplate');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/email/withTemplate');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/email/withTemplate' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/email/withTemplate' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("POST", "/baseUrl/email/withTemplate", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/email/withTemplate"
headers = {"x-postmark-server-token": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/email/withTemplate"
response <- VERB("POST", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/email/withTemplate")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/email/withTemplate') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/email/withTemplate";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/email/withTemplate \
--header 'x-postmark-server-token: 'http POST {{baseUrl}}/email/withTemplate \
x-postmark-server-token:''wget --quiet \
--method POST \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/email/withTemplateimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/email/withTemplate")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Edit Server Configuration
{{baseUrl}}/server
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/server");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/server" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/server"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/server"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/server");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/server"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/server HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/server")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/server"))
.header("x-postmark-server-token", "")
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/server")
.put(null)
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/server")
.header("x-postmark-server-token", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/server');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/server',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/server';
const options = {method: 'PUT', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/server',
method: 'PUT',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/server")
.put(null)
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/server',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/server',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/server');
req.headers({
'x-postmark-server-token': ''
});
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}}/server',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/server';
const options = {method: 'PUT', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/server"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/server" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/server",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/server', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/server');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/server');
$request->setRequestMethod('PUT');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/server' -Method PUT -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/server' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("PUT", "/baseUrl/server", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/server"
headers = {"x-postmark-server-token": ""}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/server"
response <- VERB("PUT", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/server")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/server') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/server";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/server \
--header 'x-postmark-server-token: 'http PUT {{baseUrl}}/server \
x-postmark-server-token:''wget --quiet \
--method PUT \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/serverimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/server")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get Server Configuration
{{baseUrl}}/server
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/server");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/server" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/server"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/server"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/server");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/server"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/server HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/server")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/server"))
.header("x-postmark-server-token", "")
.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}}/server")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/server")
.header("x-postmark-server-token", "")
.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}}/server');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/server',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/server';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/server',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/server")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/server',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/server',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/server');
req.headers({
'x-postmark-server-token': ''
});
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}}/server',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/server';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/server"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/server" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/server",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/server', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/server');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/server');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/server' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/server' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/server", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/server"
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/server"
response <- VERB("GET", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/server")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/server') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/server";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/server \
--header 'x-postmark-server-token: 'http GET {{baseUrl}}/server \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/serverimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/server")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get bounce counts
{{baseUrl}}/stats/outbound/bounces
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stats/outbound/bounces");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stats/outbound/bounces" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/stats/outbound/bounces"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stats/outbound/bounces"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stats/outbound/bounces");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stats/outbound/bounces"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stats/outbound/bounces HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stats/outbound/bounces")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stats/outbound/bounces"))
.header("x-postmark-server-token", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stats/outbound/bounces")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stats/outbound/bounces")
.header("x-postmark-server-token", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stats/outbound/bounces');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/bounces',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stats/outbound/bounces';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stats/outbound/bounces',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stats/outbound/bounces")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stats/outbound/bounces',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/bounces',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stats/outbound/bounces');
req.headers({
'x-postmark-server-token': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/bounces',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stats/outbound/bounces';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stats/outbound/bounces"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stats/outbound/bounces" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stats/outbound/bounces",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stats/outbound/bounces', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/stats/outbound/bounces');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stats/outbound/bounces');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/stats/outbound/bounces' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/stats/outbound/bounces' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/stats/outbound/bounces", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stats/outbound/bounces"
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/stats/outbound/bounces"
response <- VERB("GET", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stats/outbound/bounces")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stats/outbound/bounces') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stats/outbound/bounces";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stats/outbound/bounces \
--header 'x-postmark-server-token: 'http GET {{baseUrl}}/stats/outbound/bounces \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/stats/outbound/bouncesimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stats/outbound/bounces")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get browser plaform usage
{{baseUrl}}/stats/outbound/clicks/platforms
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stats/outbound/clicks/platforms");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stats/outbound/clicks/platforms" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/stats/outbound/clicks/platforms"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stats/outbound/clicks/platforms"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stats/outbound/clicks/platforms");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stats/outbound/clicks/platforms"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stats/outbound/clicks/platforms HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stats/outbound/clicks/platforms")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stats/outbound/clicks/platforms"))
.header("x-postmark-server-token", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stats/outbound/clicks/platforms")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stats/outbound/clicks/platforms")
.header("x-postmark-server-token", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stats/outbound/clicks/platforms');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/clicks/platforms',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stats/outbound/clicks/platforms';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stats/outbound/clicks/platforms',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stats/outbound/clicks/platforms")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stats/outbound/clicks/platforms',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/clicks/platforms',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stats/outbound/clicks/platforms');
req.headers({
'x-postmark-server-token': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/clicks/platforms',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stats/outbound/clicks/platforms';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stats/outbound/clicks/platforms"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stats/outbound/clicks/platforms" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stats/outbound/clicks/platforms",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stats/outbound/clicks/platforms', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/stats/outbound/clicks/platforms');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stats/outbound/clicks/platforms');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/stats/outbound/clicks/platforms' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/stats/outbound/clicks/platforms' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/stats/outbound/clicks/platforms", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stats/outbound/clicks/platforms"
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/stats/outbound/clicks/platforms"
response <- VERB("GET", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stats/outbound/clicks/platforms")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stats/outbound/clicks/platforms') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stats/outbound/clicks/platforms";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stats/outbound/clicks/platforms \
--header 'x-postmark-server-token: 'http GET {{baseUrl}}/stats/outbound/clicks/platforms \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/stats/outbound/clicks/platformsimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stats/outbound/clicks/platforms")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get browser usage by family
{{baseUrl}}/stats/outbound/clicks/browserfamilies
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stats/outbound/clicks/browserfamilies");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stats/outbound/clicks/browserfamilies" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/stats/outbound/clicks/browserfamilies"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stats/outbound/clicks/browserfamilies"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stats/outbound/clicks/browserfamilies");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stats/outbound/clicks/browserfamilies"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stats/outbound/clicks/browserfamilies HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stats/outbound/clicks/browserfamilies")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stats/outbound/clicks/browserfamilies"))
.header("x-postmark-server-token", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stats/outbound/clicks/browserfamilies")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stats/outbound/clicks/browserfamilies")
.header("x-postmark-server-token", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stats/outbound/clicks/browserfamilies');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/clicks/browserfamilies',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stats/outbound/clicks/browserfamilies';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stats/outbound/clicks/browserfamilies',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stats/outbound/clicks/browserfamilies")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stats/outbound/clicks/browserfamilies',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/clicks/browserfamilies',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stats/outbound/clicks/browserfamilies');
req.headers({
'x-postmark-server-token': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/clicks/browserfamilies',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stats/outbound/clicks/browserfamilies';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stats/outbound/clicks/browserfamilies"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stats/outbound/clicks/browserfamilies" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stats/outbound/clicks/browserfamilies",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stats/outbound/clicks/browserfamilies', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/stats/outbound/clicks/browserfamilies');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stats/outbound/clicks/browserfamilies');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/stats/outbound/clicks/browserfamilies' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/stats/outbound/clicks/browserfamilies' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/stats/outbound/clicks/browserfamilies", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stats/outbound/clicks/browserfamilies"
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/stats/outbound/clicks/browserfamilies"
response <- VERB("GET", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stats/outbound/clicks/browserfamilies")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stats/outbound/clicks/browserfamilies') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stats/outbound/clicks/browserfamilies";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stats/outbound/clicks/browserfamilies \
--header 'x-postmark-server-token: 'http GET {{baseUrl}}/stats/outbound/clicks/browserfamilies \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/stats/outbound/clicks/browserfamiliesimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stats/outbound/clicks/browserfamilies")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get click counts
{{baseUrl}}/stats/outbound/clicks
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stats/outbound/clicks");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stats/outbound/clicks" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/stats/outbound/clicks"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stats/outbound/clicks"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stats/outbound/clicks");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stats/outbound/clicks"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stats/outbound/clicks HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stats/outbound/clicks")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stats/outbound/clicks"))
.header("x-postmark-server-token", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stats/outbound/clicks")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stats/outbound/clicks")
.header("x-postmark-server-token", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stats/outbound/clicks');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/clicks',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stats/outbound/clicks';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stats/outbound/clicks',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stats/outbound/clicks")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stats/outbound/clicks',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/clicks',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stats/outbound/clicks');
req.headers({
'x-postmark-server-token': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/clicks',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stats/outbound/clicks';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stats/outbound/clicks"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stats/outbound/clicks" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stats/outbound/clicks",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stats/outbound/clicks', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/stats/outbound/clicks');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stats/outbound/clicks');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/stats/outbound/clicks' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/stats/outbound/clicks' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/stats/outbound/clicks", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stats/outbound/clicks"
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/stats/outbound/clicks"
response <- VERB("GET", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stats/outbound/clicks")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stats/outbound/clicks') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stats/outbound/clicks";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stats/outbound/clicks \
--header 'x-postmark-server-token: 'http GET {{baseUrl}}/stats/outbound/clicks \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/stats/outbound/clicksimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stats/outbound/clicks")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get clicks by body location
{{baseUrl}}/stats/outbound/clicks/location
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stats/outbound/clicks/location");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stats/outbound/clicks/location" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/stats/outbound/clicks/location"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stats/outbound/clicks/location"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stats/outbound/clicks/location");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stats/outbound/clicks/location"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stats/outbound/clicks/location HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stats/outbound/clicks/location")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stats/outbound/clicks/location"))
.header("x-postmark-server-token", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stats/outbound/clicks/location")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stats/outbound/clicks/location")
.header("x-postmark-server-token", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stats/outbound/clicks/location');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/clicks/location',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stats/outbound/clicks/location';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stats/outbound/clicks/location',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stats/outbound/clicks/location")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stats/outbound/clicks/location',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/clicks/location',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stats/outbound/clicks/location');
req.headers({
'x-postmark-server-token': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/clicks/location',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stats/outbound/clicks/location';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stats/outbound/clicks/location"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stats/outbound/clicks/location" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stats/outbound/clicks/location",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stats/outbound/clicks/location', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/stats/outbound/clicks/location');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stats/outbound/clicks/location');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/stats/outbound/clicks/location' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/stats/outbound/clicks/location' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/stats/outbound/clicks/location", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stats/outbound/clicks/location"
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/stats/outbound/clicks/location"
response <- VERB("GET", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stats/outbound/clicks/location")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stats/outbound/clicks/location') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stats/outbound/clicks/location";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stats/outbound/clicks/location \
--header 'x-postmark-server-token: 'http GET {{baseUrl}}/stats/outbound/clicks/location \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/stats/outbound/clicks/locationimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stats/outbound/clicks/location")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get email client usage
{{baseUrl}}/stats/outbound/opens/emailclients
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stats/outbound/opens/emailclients");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stats/outbound/opens/emailclients" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/stats/outbound/opens/emailclients"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stats/outbound/opens/emailclients"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stats/outbound/opens/emailclients");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stats/outbound/opens/emailclients"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stats/outbound/opens/emailclients HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stats/outbound/opens/emailclients")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stats/outbound/opens/emailclients"))
.header("x-postmark-server-token", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stats/outbound/opens/emailclients")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stats/outbound/opens/emailclients")
.header("x-postmark-server-token", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stats/outbound/opens/emailclients');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/opens/emailclients',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stats/outbound/opens/emailclients';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stats/outbound/opens/emailclients',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stats/outbound/opens/emailclients")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stats/outbound/opens/emailclients',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/opens/emailclients',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stats/outbound/opens/emailclients');
req.headers({
'x-postmark-server-token': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/opens/emailclients',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stats/outbound/opens/emailclients';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stats/outbound/opens/emailclients"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stats/outbound/opens/emailclients" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stats/outbound/opens/emailclients",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stats/outbound/opens/emailclients', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/stats/outbound/opens/emailclients');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stats/outbound/opens/emailclients');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/stats/outbound/opens/emailclients' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/stats/outbound/opens/emailclients' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/stats/outbound/opens/emailclients", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stats/outbound/opens/emailclients"
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/stats/outbound/opens/emailclients"
response <- VERB("GET", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stats/outbound/opens/emailclients")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stats/outbound/opens/emailclients') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stats/outbound/opens/emailclients";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stats/outbound/opens/emailclients \
--header 'x-postmark-server-token: 'http GET {{baseUrl}}/stats/outbound/opens/emailclients \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/stats/outbound/opens/emailclientsimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stats/outbound/opens/emailclients")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get email open counts
{{baseUrl}}/stats/outbound/opens
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stats/outbound/opens");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stats/outbound/opens" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/stats/outbound/opens"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stats/outbound/opens"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stats/outbound/opens");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stats/outbound/opens"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stats/outbound/opens HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stats/outbound/opens")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stats/outbound/opens"))
.header("x-postmark-server-token", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stats/outbound/opens")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stats/outbound/opens")
.header("x-postmark-server-token", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stats/outbound/opens');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/opens',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stats/outbound/opens';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stats/outbound/opens',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stats/outbound/opens")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stats/outbound/opens',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/opens',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stats/outbound/opens');
req.headers({
'x-postmark-server-token': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/opens',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stats/outbound/opens';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stats/outbound/opens"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stats/outbound/opens" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stats/outbound/opens",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stats/outbound/opens', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/stats/outbound/opens');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stats/outbound/opens');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/stats/outbound/opens' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/stats/outbound/opens' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/stats/outbound/opens", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stats/outbound/opens"
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/stats/outbound/opens"
response <- VERB("GET", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stats/outbound/opens")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stats/outbound/opens') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stats/outbound/opens";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stats/outbound/opens \
--header 'x-postmark-server-token: 'http GET {{baseUrl}}/stats/outbound/opens \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/stats/outbound/opensimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stats/outbound/opens")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get email platform usage
{{baseUrl}}/stats/outbound/opens/platforms
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stats/outbound/opens/platforms");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stats/outbound/opens/platforms" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/stats/outbound/opens/platforms"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stats/outbound/opens/platforms"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stats/outbound/opens/platforms");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stats/outbound/opens/platforms"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stats/outbound/opens/platforms HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stats/outbound/opens/platforms")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stats/outbound/opens/platforms"))
.header("x-postmark-server-token", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stats/outbound/opens/platforms")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stats/outbound/opens/platforms")
.header("x-postmark-server-token", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stats/outbound/opens/platforms');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/opens/platforms',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stats/outbound/opens/platforms';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stats/outbound/opens/platforms',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stats/outbound/opens/platforms")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stats/outbound/opens/platforms',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/opens/platforms',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stats/outbound/opens/platforms');
req.headers({
'x-postmark-server-token': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/opens/platforms',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stats/outbound/opens/platforms';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stats/outbound/opens/platforms"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stats/outbound/opens/platforms" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stats/outbound/opens/platforms",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stats/outbound/opens/platforms', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/stats/outbound/opens/platforms');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stats/outbound/opens/platforms');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/stats/outbound/opens/platforms' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/stats/outbound/opens/platforms' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/stats/outbound/opens/platforms", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stats/outbound/opens/platforms"
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/stats/outbound/opens/platforms"
response <- VERB("GET", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stats/outbound/opens/platforms")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stats/outbound/opens/platforms') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stats/outbound/opens/platforms";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stats/outbound/opens/platforms \
--header 'x-postmark-server-token: 'http GET {{baseUrl}}/stats/outbound/opens/platforms \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/stats/outbound/opens/platformsimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stats/outbound/opens/platforms")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get outbound overview
{{baseUrl}}/stats/outbound
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stats/outbound");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stats/outbound" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/stats/outbound"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stats/outbound"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stats/outbound");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stats/outbound"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stats/outbound HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stats/outbound")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stats/outbound"))
.header("x-postmark-server-token", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stats/outbound")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stats/outbound")
.header("x-postmark-server-token", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stats/outbound');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stats/outbound';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stats/outbound',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stats/outbound")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stats/outbound',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stats/outbound');
req.headers({
'x-postmark-server-token': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stats/outbound';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stats/outbound"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stats/outbound" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stats/outbound",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stats/outbound', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/stats/outbound');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stats/outbound');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/stats/outbound' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/stats/outbound' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/stats/outbound", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stats/outbound"
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/stats/outbound"
response <- VERB("GET", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stats/outbound")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stats/outbound') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stats/outbound";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stats/outbound \
--header 'x-postmark-server-token: 'http GET {{baseUrl}}/stats/outbound \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/stats/outboundimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stats/outbound")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get sent counts
{{baseUrl}}/stats/outbound/sends
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stats/outbound/sends");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stats/outbound/sends" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/stats/outbound/sends"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stats/outbound/sends"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stats/outbound/sends");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stats/outbound/sends"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stats/outbound/sends HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stats/outbound/sends")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stats/outbound/sends"))
.header("x-postmark-server-token", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stats/outbound/sends")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stats/outbound/sends")
.header("x-postmark-server-token", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stats/outbound/sends');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/sends',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stats/outbound/sends';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stats/outbound/sends',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stats/outbound/sends")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stats/outbound/sends',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/sends',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stats/outbound/sends');
req.headers({
'x-postmark-server-token': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/sends',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stats/outbound/sends';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stats/outbound/sends"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stats/outbound/sends" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stats/outbound/sends",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stats/outbound/sends', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/stats/outbound/sends');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stats/outbound/sends');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/stats/outbound/sends' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/stats/outbound/sends' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/stats/outbound/sends", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stats/outbound/sends"
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/stats/outbound/sends"
response <- VERB("GET", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stats/outbound/sends")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stats/outbound/sends') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stats/outbound/sends";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stats/outbound/sends \
--header 'x-postmark-server-token: 'http GET {{baseUrl}}/stats/outbound/sends \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/stats/outbound/sendsimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stats/outbound/sends")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get spam complaints
{{baseUrl}}/stats/outbound/spam
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stats/outbound/spam");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stats/outbound/spam" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/stats/outbound/spam"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stats/outbound/spam"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stats/outbound/spam");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stats/outbound/spam"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stats/outbound/spam HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stats/outbound/spam")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stats/outbound/spam"))
.header("x-postmark-server-token", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stats/outbound/spam")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stats/outbound/spam")
.header("x-postmark-server-token", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stats/outbound/spam');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/spam',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stats/outbound/spam';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stats/outbound/spam',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stats/outbound/spam")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stats/outbound/spam',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/spam',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stats/outbound/spam');
req.headers({
'x-postmark-server-token': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/spam',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stats/outbound/spam';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stats/outbound/spam"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stats/outbound/spam" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stats/outbound/spam",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stats/outbound/spam', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/stats/outbound/spam');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stats/outbound/spam');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/stats/outbound/spam' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/stats/outbound/spam' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/stats/outbound/spam", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stats/outbound/spam"
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/stats/outbound/spam"
response <- VERB("GET", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stats/outbound/spam")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stats/outbound/spam') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stats/outbound/spam";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stats/outbound/spam \
--header 'x-postmark-server-token: 'http GET {{baseUrl}}/stats/outbound/spam \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/stats/outbound/spamimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stats/outbound/spam")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get tracked email counts
{{baseUrl}}/stats/outbound/tracked
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stats/outbound/tracked");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stats/outbound/tracked" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/stats/outbound/tracked"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stats/outbound/tracked"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stats/outbound/tracked");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stats/outbound/tracked"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stats/outbound/tracked HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stats/outbound/tracked")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stats/outbound/tracked"))
.header("x-postmark-server-token", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stats/outbound/tracked")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stats/outbound/tracked")
.header("x-postmark-server-token", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stats/outbound/tracked');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/tracked',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stats/outbound/tracked';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stats/outbound/tracked',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stats/outbound/tracked")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stats/outbound/tracked',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/tracked',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stats/outbound/tracked');
req.headers({
'x-postmark-server-token': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/outbound/tracked',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stats/outbound/tracked';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stats/outbound/tracked"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stats/outbound/tracked" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stats/outbound/tracked",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stats/outbound/tracked', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/stats/outbound/tracked');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stats/outbound/tracked');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/stats/outbound/tracked' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/stats/outbound/tracked' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/stats/outbound/tracked", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stats/outbound/tracked"
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/stats/outbound/tracked"
response <- VERB("GET", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stats/outbound/tracked")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stats/outbound/tracked') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stats/outbound/tracked";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stats/outbound/tracked \
--header 'x-postmark-server-token: 'http GET {{baseUrl}}/stats/outbound/tracked \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/stats/outbound/trackedimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stats/outbound/tracked")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create a Template
{{baseUrl}}/templates
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/templates");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/templates" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/templates"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/templates"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/templates");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/templates"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/templates HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/templates")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/templates"))
.header("x-postmark-server-token", "")
.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}}/templates")
.post(null)
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/templates")
.header("x-postmark-server-token", "")
.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}}/templates');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/templates',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/templates';
const options = {method: 'POST', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/templates',
method: 'POST',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/templates")
.post(null)
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/templates',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/templates',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/templates');
req.headers({
'x-postmark-server-token': ''
});
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}}/templates',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/templates';
const options = {method: 'POST', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/templates"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/templates" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/templates",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/templates', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/templates');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/templates');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/templates' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/templates' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("POST", "/baseUrl/templates", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/templates"
headers = {"x-postmark-server-token": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/templates"
response <- VERB("POST", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/templates")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/templates') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/templates";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/templates \
--header 'x-postmark-server-token: 'http POST {{baseUrl}}/templates \
x-postmark-server-token:''wget --quiet \
--method POST \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/templatesimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/templates")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete a Template
{{baseUrl}}/templates/:templateIdOrAlias
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
templateIdOrAlias
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/templates/:templateIdOrAlias");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/templates/:templateIdOrAlias" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/templates/:templateIdOrAlias"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/templates/:templateIdOrAlias"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/templates/:templateIdOrAlias");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/templates/:templateIdOrAlias"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/templates/:templateIdOrAlias HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/templates/:templateIdOrAlias")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/templates/:templateIdOrAlias"))
.header("x-postmark-server-token", "")
.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}}/templates/:templateIdOrAlias")
.delete(null)
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/templates/:templateIdOrAlias")
.header("x-postmark-server-token", "")
.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}}/templates/:templateIdOrAlias');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/templates/:templateIdOrAlias',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/templates/:templateIdOrAlias';
const options = {method: 'DELETE', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/templates/:templateIdOrAlias',
method: 'DELETE',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/templates/:templateIdOrAlias")
.delete(null)
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/templates/:templateIdOrAlias',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/templates/:templateIdOrAlias',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/templates/:templateIdOrAlias');
req.headers({
'x-postmark-server-token': ''
});
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}}/templates/:templateIdOrAlias',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/templates/:templateIdOrAlias';
const options = {method: 'DELETE', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/templates/:templateIdOrAlias"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/templates/:templateIdOrAlias" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/templates/:templateIdOrAlias",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/templates/:templateIdOrAlias', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/templates/:templateIdOrAlias');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/templates/:templateIdOrAlias');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/templates/:templateIdOrAlias' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/templates/:templateIdOrAlias' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("DELETE", "/baseUrl/templates/:templateIdOrAlias", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/templates/:templateIdOrAlias"
headers = {"x-postmark-server-token": ""}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/templates/:templateIdOrAlias"
response <- VERB("DELETE", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/templates/:templateIdOrAlias")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/templates/:templateIdOrAlias') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/templates/:templateIdOrAlias";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/templates/:templateIdOrAlias \
--header 'x-postmark-server-token: 'http DELETE {{baseUrl}}/templates/:templateIdOrAlias \
x-postmark-server-token:''wget --quiet \
--method DELETE \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/templates/:templateIdOrAliasimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/templates/:templateIdOrAlias")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get a Template
{{baseUrl}}/templates/:templateIdOrAlias
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
templateIdOrAlias
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/templates/:templateIdOrAlias");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/templates/:templateIdOrAlias" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/templates/:templateIdOrAlias"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/templates/:templateIdOrAlias"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/templates/:templateIdOrAlias");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/templates/:templateIdOrAlias"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/templates/:templateIdOrAlias HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/templates/:templateIdOrAlias")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/templates/:templateIdOrAlias"))
.header("x-postmark-server-token", "")
.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}}/templates/:templateIdOrAlias")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/templates/:templateIdOrAlias")
.header("x-postmark-server-token", "")
.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}}/templates/:templateIdOrAlias');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/templates/:templateIdOrAlias',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/templates/:templateIdOrAlias';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/templates/:templateIdOrAlias',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/templates/:templateIdOrAlias")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/templates/:templateIdOrAlias',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/templates/:templateIdOrAlias',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/templates/:templateIdOrAlias');
req.headers({
'x-postmark-server-token': ''
});
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}}/templates/:templateIdOrAlias',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/templates/:templateIdOrAlias';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/templates/:templateIdOrAlias"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/templates/:templateIdOrAlias" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/templates/:templateIdOrAlias",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/templates/:templateIdOrAlias', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/templates/:templateIdOrAlias');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/templates/:templateIdOrAlias');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/templates/:templateIdOrAlias' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/templates/:templateIdOrAlias' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/templates/:templateIdOrAlias", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/templates/:templateIdOrAlias"
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/templates/:templateIdOrAlias"
response <- VERB("GET", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/templates/:templateIdOrAlias")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/templates/:templateIdOrAlias') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/templates/:templateIdOrAlias";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/templates/:templateIdOrAlias \
--header 'x-postmark-server-token: 'http GET {{baseUrl}}/templates/:templateIdOrAlias \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/templates/:templateIdOrAliasimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/templates/:templateIdOrAlias")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get the Templates associated with this Server
{{baseUrl}}/templates
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
Count
Offset
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/templates?Count=&Offset=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/templates" {:headers {:x-postmark-server-token ""}
:query-params {:Count ""
:Offset ""}})require "http/client"
url = "{{baseUrl}}/templates?Count=&Offset="
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/templates?Count=&Offset="),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/templates?Count=&Offset=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/templates?Count=&Offset="
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/templates?Count=&Offset= HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/templates?Count=&Offset=")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/templates?Count=&Offset="))
.header("x-postmark-server-token", "")
.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}}/templates?Count=&Offset=")
.get()
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/templates?Count=&Offset=")
.header("x-postmark-server-token", "")
.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}}/templates?Count=&Offset=');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/templates',
params: {Count: '', Offset: ''},
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/templates?Count=&Offset=';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/templates?Count=&Offset=',
method: 'GET',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/templates?Count=&Offset=")
.get()
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/templates?Count=&Offset=',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/templates',
qs: {Count: '', Offset: ''},
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/templates');
req.query({
Count: '',
Offset: ''
});
req.headers({
'x-postmark-server-token': ''
});
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}}/templates',
params: {Count: '', Offset: ''},
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/templates?Count=&Offset=';
const options = {method: 'GET', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/templates?Count=&Offset="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/templates?Count=&Offset=" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/templates?Count=&Offset=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/templates?Count=&Offset=', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/templates');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'Count' => '',
'Offset' => ''
]);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/templates');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'Count' => '',
'Offset' => ''
]));
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/templates?Count=&Offset=' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/templates?Count=&Offset=' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("GET", "/baseUrl/templates?Count=&Offset=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/templates"
querystring = {"Count":"","Offset":""}
headers = {"x-postmark-server-token": ""}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/templates"
queryString <- list(
Count = "",
Offset = ""
)
response <- VERB("GET", url, query = queryString, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/templates?Count=&Offset=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/templates') do |req|
req.headers['x-postmark-server-token'] = ''
req.params['Count'] = ''
req.params['Offset'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/templates";
let querystring = [
("Count", ""),
("Offset", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/templates?Count=&Offset=' \
--header 'x-postmark-server-token: 'http GET '{{baseUrl}}/templates?Count=&Offset=' \
x-postmark-server-token:''wget --quiet \
--method GET \
--header 'x-postmark-server-token: ' \
--output-document \
- '{{baseUrl}}/templates?Count=&Offset='import Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/templates?Count=&Offset=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Test Template Content
{{baseUrl}}/templates/validate
HEADERS
X-Postmark-Server-Token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/templates/validate");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/templates/validate" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/templates/validate"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/templates/validate"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/templates/validate");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/templates/validate"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/templates/validate HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/templates/validate")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/templates/validate"))
.header("x-postmark-server-token", "")
.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}}/templates/validate")
.post(null)
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/templates/validate")
.header("x-postmark-server-token", "")
.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}}/templates/validate');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/templates/validate',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/templates/validate';
const options = {method: 'POST', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/templates/validate',
method: 'POST',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/templates/validate")
.post(null)
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/templates/validate',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
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}}/templates/validate',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/templates/validate');
req.headers({
'x-postmark-server-token': ''
});
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}}/templates/validate',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/templates/validate';
const options = {method: 'POST', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/templates/validate"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/templates/validate" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/templates/validate",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/templates/validate', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/templates/validate');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/templates/validate');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/templates/validate' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/templates/validate' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("POST", "/baseUrl/templates/validate", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/templates/validate"
headers = {"x-postmark-server-token": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/templates/validate"
response <- VERB("POST", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/templates/validate")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/templates/validate') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/templates/validate";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/templates/validate \
--header 'x-postmark-server-token: 'http POST {{baseUrl}}/templates/validate \
x-postmark-server-token:''wget --quiet \
--method POST \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/templates/validateimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/templates/validate")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Update a Template
{{baseUrl}}/templates/:templateIdOrAlias
HEADERS
X-Postmark-Server-Token
QUERY PARAMS
templateIdOrAlias
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/templates/:templateIdOrAlias");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-postmark-server-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/templates/:templateIdOrAlias" {:headers {:x-postmark-server-token ""}})require "http/client"
url = "{{baseUrl}}/templates/:templateIdOrAlias"
headers = HTTP::Headers{
"x-postmark-server-token" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/templates/:templateIdOrAlias"),
Headers =
{
{ "x-postmark-server-token", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/templates/:templateIdOrAlias");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-postmark-server-token", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/templates/:templateIdOrAlias"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("x-postmark-server-token", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/templates/:templateIdOrAlias HTTP/1.1
X-Postmark-Server-Token:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/templates/:templateIdOrAlias")
.setHeader("x-postmark-server-token", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/templates/:templateIdOrAlias"))
.header("x-postmark-server-token", "")
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/templates/:templateIdOrAlias")
.put(null)
.addHeader("x-postmark-server-token", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/templates/:templateIdOrAlias")
.header("x-postmark-server-token", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/templates/:templateIdOrAlias');
xhr.setRequestHeader('x-postmark-server-token', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/templates/:templateIdOrAlias',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/templates/:templateIdOrAlias';
const options = {method: 'PUT', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/templates/:templateIdOrAlias',
method: 'PUT',
headers: {
'x-postmark-server-token': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/templates/:templateIdOrAlias")
.put(null)
.addHeader("x-postmark-server-token", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/templates/:templateIdOrAlias',
headers: {
'x-postmark-server-token': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/templates/:templateIdOrAlias',
headers: {'x-postmark-server-token': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/templates/:templateIdOrAlias');
req.headers({
'x-postmark-server-token': ''
});
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}}/templates/:templateIdOrAlias',
headers: {'x-postmark-server-token': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/templates/:templateIdOrAlias';
const options = {method: 'PUT', headers: {'x-postmark-server-token': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-postmark-server-token": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/templates/:templateIdOrAlias"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/templates/:templateIdOrAlias" in
let headers = Header.add (Header.init ()) "x-postmark-server-token" "" in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/templates/:templateIdOrAlias",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"x-postmark-server-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/templates/:templateIdOrAlias', [
'headers' => [
'x-postmark-server-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/templates/:templateIdOrAlias');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'x-postmark-server-token' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/templates/:templateIdOrAlias');
$request->setRequestMethod('PUT');
$request->setHeaders([
'x-postmark-server-token' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/templates/:templateIdOrAlias' -Method PUT -Headers $headers$headers=@{}
$headers.Add("x-postmark-server-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/templates/:templateIdOrAlias' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-postmark-server-token': "" }
conn.request("PUT", "/baseUrl/templates/:templateIdOrAlias", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/templates/:templateIdOrAlias"
headers = {"x-postmark-server-token": ""}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/templates/:templateIdOrAlias"
response <- VERB("PUT", url, add_headers('x-postmark-server-token' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/templates/:templateIdOrAlias")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["x-postmark-server-token"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/templates/:templateIdOrAlias') do |req|
req.headers['x-postmark-server-token'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/templates/:templateIdOrAlias";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-postmark-server-token", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/templates/:templateIdOrAlias \
--header 'x-postmark-server-token: 'http PUT {{baseUrl}}/templates/:templateIdOrAlias \
x-postmark-server-token:''wget --quiet \
--method PUT \
--header 'x-postmark-server-token: ' \
--output-document \
- {{baseUrl}}/templates/:templateIdOrAliasimport Foundation
let headers = ["x-postmark-server-token": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/templates/:templateIdOrAlias")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()